집합 자료형과 집합연산_python

python에서는 set이라는 집합 자료형을 제공합니다. 이 자료형은 집합들 간의 합집합 등의 연산을 위해 사용되는 형태입니다.
이번 글에서는 python 의 set 자료형에 의한 연산 종류를 알아봅니다.
우선 리스트등의 자료형을 집합형으로 전환하기위해서 set() 함수를 사용합니다.
다음은 주사위 두개를 던져 나올수 있는 모든 경우입니다.

>>> S=[(i, j) for i in range(1, 7) for j in range(1, 7)]
>>> print(S)
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)]

다음 A와 B는 각각 두수의 합이 2의 배수, 3의 배수인 경우입니다.

>>> A=[(S[i][0], S[i][1]) for i in range(len(S)) if (S[i][0]+S[i][1])%2 ==0]
>>> print(A)
[(1, 1), (1, 3), (1, 5), (2, 2), (2, 4), (2, 6), (3, 1), (3, 3), (3, 5), (4, 2), (4, 4), (4, 6), (5, 1), (5, 3), (5, 5), (6, 2), (6, 4), (6, 6)]

>>> B=[(S[i][0], S[i][1]) for i in range(len(S)) if (S[i][0]+S[i][1])%3 ==0]
>>> print(B)
[(1, 2), (1, 5), (2, 1), (2, 4), (3, 3), (3, 6), (4, 2), (4, 5), (5, 1), (5, 4), (6, 3), (6, 6)]

1. 집합형으로 전환

위 결과들에 대한 집합연산을 위해서는 모두 set 형으로 변형하여야 합니다.
S1=set(S)
print(S1)
{(1, 3), (6, 6), ...(2, 4)}

A1=set(A)
print(A1)
{(6, 4), (5, 1), ..., (3, 5)}

B1=set(B)
print(B1)
{(1, 2), (5, 1), ..., (2, 4)}

또한 하나의 문자열을 set()으로 전환하는 경우 각각의 문자가 원소가 되며 순서 정렬합니다.
>>> set("Python has set datatype.")
{' ', '.', 'P', 'a', 'd', 'e', 'h', 'n', 'o', 'p', 's', 't', 'y'}
그러나 리스트, 튜플 등으로 여러개의 문자열을 집합형으로 전환할 경우 각 문자열이 원소가 됩니다.

집합형은 인덱스를 사용하여 각 원소를 호출할 수 없습니다.
>>> cities = set(("Paris", "Lyon", "London","Berlin","Paris","Birmingham"))
>>> cities
{'Berlin', 'Birmingham', 'London', 'Lyon', 'Paris'}
>>> cities[0]
Traceback (most recent call last):
  File "<ipython-input-38-77ba3d1ba708>", line 1, in <module>
    cities[0]
TypeError: 'set' object does not support indexing

주사위의 예는 리스트 자료형을 set형으로 전환하였습니다. 그러나 집합의 원소가 리스형이 되는 것은 허락되지 않습니다.
다음은 각 원소가 튜플형이므로 집합형으로 전환이 가능합니다.
>>> cities = set((("Python","Perl"), ("Paris", "Berlin", "London")))
>>> cities
{('Paris', 'Berlin', 'London'), ('Python', 'Perl')}
그러나 다음은 각 원소가 리스트 형태이므로 전환이 이루어지지 않습니다.
>>> cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))
>>> cities
Traceback (most recent call last):

  File "<ipython-input-41-420df19bb866>", line 1, in <module>
    cities = set((["Python","Perl"], ["Paris", "Berlin", "London"]))

TypeError: unhashable type: 'list'

즉 집합형에서 각 원소는 수정할 수 없다는 것을 의미합니다.
그러나 집합자체에 새로운 원소를 첨가하는 것은 가능합니다.
>>> cities = set(("서울", "부산", "광주"))
>>> cities
{'광주', '부산', '서울'}

>>> cities.add("평창")
>>> cities
{'광주', '부산', '서울', '평창'}

원래의 집합 데이터를 보존하기 위해서는 frozenset()를 사용합니다. 이 경우는 위와 같은 집합차원에서의 수정이 불가능해 집니다.
>>> cities = frozenset(("서울", "부산", "광주"))
>>> cities
frozenset({'광주', '부산', '서울'})

>>> cities.add("평창")
>>> cities
Traceback (most recent call last):

  File "<ipython-input-45-f9b630b3fb0d>", line 1, in <module>
    cities.add("평창")

AttributeError: 'frozenset' object has no attribute 'add'

집합기호를 사용하여 직접적으로 집합 데이터를 만들 수 있습니다.
>>> cities = {"서울", "부산", "광주"}
>>> cities
{'광주', '부산', '서울'}

2. 집합연산

1) add(원소) : 새로운 원소 또는 원소들을 첨가합니다. 원소들을 첨가할 경우는 튜플형만 가능하고 리스트형이나 집합형은 첨가할 수 없습니다. 

>>> col={'r', 'g'}

>>> col.add('y')

>>> col

{'g', 'r', 'y'}

>>> col.add(('b', 'w'))

>>> col

{'g', ('b', 'w'), 'y', 'r'}

>>> col.add(['yr','yg'])

Traceback (most recent call last):

  File "<ipython-input-51-c1ab7ecb125b>", line 1, in <module>

    col.add(['yr','yg'])

TypeError: unhashable type: 'list'

>>> col.add({'yr','yg'})

Traceback (most recent call last):

  File "<ipython-input-52-a5a392606419>", line 1, in <module>

    col.add({'yr','yg'})

TypeError: unhashable type: 'set'

2) clear() : 집합으로 부터 모든 원소를 제거합니다. 

>>> col.clear()

>>> col

set()

3) copy(): 집합형 데이터들을 얉은복사 합니다.
>>> col = {'g', ('b', 'w'), 'y', 'r'}
>>> col1=col.copy()
>>> col1
{'g', ('b', 'w'), 'y', 'r'}

>>> col1.clear()
>>> col
{'g', ('b', 'w'), 'y', 'r'}

>>> col1
set()

4) difference(): 두개 이상의 집합들사이의 차집합을 계산합니다. 이 계산은 '_'를 사용하여 동일한 연산을 할 수 있습니다.
>>> col={'r', 'g'}
>>> col1={'g', ('b', 'w'), 'y', 'r'}
>>> col2={'g', 'y', }
>>> col1.difference(col)
{('b', 'w'), 'y'}
>>> col1-col
{('b', 'w'), 'y'}
>>> col1.difference(col). difference(col2)
{('b', 'w')}
>>> col1-col-col2
{('b', 'w')}

5) difference_update(): 이 함수역수 역시 차집합을 계산하는 것이지만 difference()는 참집합 연산에 의한 새로운 객체를 생성하는 것에 반해 이 함수는 원 함수를 차집합 연산의 결과로 대체합니다. 즉, 결과는 다음과 같습니다.
'x = x-y'
>>> col1
{'g', ('b', 'w'), 'y', 'r'}
>>> col1.difference_update(col)
>>> col1
{'y', ('b', 'w')}

6) discard(원소), remove(원소): 집합의 원소를 삭제합니다. 삭제하려는 원소가 집합내에 존재할 경우 두 함수는 동일하게 작동하지만 그 집합내에 존재하지 않을 경우는 discard()는 원래의 집합을 결과로 반환하지만 remove()의 경우는 에러가 발생합니다.
>>> cities = {"서울", "부산", "광주"}
>>> cities.discard("부산")
>>> cities
{'광주', '서울'}
>>> cities.remove("광주")
>>> cities
{'서울'}
>>> cities.discard("평양")
>>> cities
{'서울'}
>>> cities.remove("평양")
Traceback (most recent call last):
  File "<ipython-input-117-763816845874>", line 1, in <module>
    cities.remove("평양")
KeyError: '평양'

7) union(), "|": 합집합
>>> col={'r', 'g'}
>>> col2={'g', 'y', }
>>> col.union(col2)
{'g', 'r', 'y'}
>>> col|col2
{'g', 'r', 'y'}

8) intersection() , "&" : 교집합
>>> col.intersection(col2)
{'g'}
>>> col & col2
{'g'}

9) isdisjoint(): 두 집합의 독립성을 판단하는 함수로서 교집합이 없다면 True, 교집합이 존재하면 False를 반환합니다.
>>> x = {"a","b","c"}
>>> y = {"c","d","e"}
>>> x.isdisjoint(y)
False
>>> y1 = {"d","e","f"}
>>> x.isdisjoint(y1)
True
10) issubset() : 부분집합의 여부를 검정합니다. 이것은 '<', '<="로 대신할 수 있습니다.
x.issubset(y) : x 가 y의 부분집합? 이것은 x<y
>>> x = {"a","b","c", "d","e"}
>>> y = {"d","e"}
>>> x.issubset(y)
 False
>>> y.issubset(x)
True
>>> y<x
True
>>> x<x
False
>>> x<=x
True

11) issuperset() : issubset()과 같이 부분집합을 검사하는 것이지만 비교 대상의 위치가 반대입니다. ">" 또는 ">="으로 대신할 수 있습니다.
x.issuperset(y) : y가 x의 부분집합, x>y
>>> x.issuperset(y)
True

12) pop() : 집합의 임의의 원소를 제거한후 제거한 원소를 반환합니다. 원래의 객체는 원소 하나가 제거된 상태로 수정됩니다. 집합이 공집합일 경우 에러가 발생합니다.
>>> x.pop()
 'a'
>>> x
{'b', 'c', 'd', 'e'}
>>> x.pop()
'e'
>>> x
{'b', 'c', 'd'}