0902_3일차_셋

이번에는 셋 데이터입니다.

 

---

set, 집합 자료형이구요.
순서가 없고, 중복도 불가합니다.
순서, 중복이 없으니 매번 값이 랜덤하게 출력되구요. 그래서 셋형은 인덱싱과 슬라이싱이 불가합니다.
데이터는 변경, 수정이 가능합니다.. (mutable).
하지만, set에 데이터를 저장할 때, 데이터는 immutable해야합니다. => mutable한 리스트형은 셋형의 데이터가 될 수 없습니다.

"""
    집합형 자료형
    1) 문자열
    2) 리스트
    3) 튜플
    4) 셋
        a. 문자열 생성 방법
            (1) {값, 값2} 직접 사용
            (2) set(변수명)

        b. 문자열 제공 함수    ==> dir(set) 확인 가능

        ## c. 인덱싱 및 슬라이싱   ==> 순서가 없기때문에 불가
        c. 문자열 특징
            - 순서가 없고 중복 불가 ==> 인덱싱, 슬라이싱 불가
            - 저장되는 데이터는 반드시 immutable해야 함. (정수, 문자열, 튜플) => 리스트(mutable)는 Error
"""

---

 

---

셋set 형 생성은 직접 데이터에 중괄호 { }를 씌워서 할 수도 있고,
set()함수를 이용해서 형변환 시켜줄 수도 있습니다.
( [리스트]형도 형변환으로 set형으로 만들 수는 있습니다만 [리스트]형이 set의 데이터가 될 수는 없습니다. 뒤에서 더 설명하겠습니다.)

#1. 셋 생성
m = {9, 8, 7, 6, 6} # 중복값 1회 출력 ( 중복 불가 )
m2 = set()  # 빈 셋 생성 가능
m3 = set("hello")
m4 = set([9, 8, 7])         # set()을 이용해서 [리스트]를 set으로 형변환할 수는 있다.
print(m, type(m))           # {8, 9, 6, 7} <class 'set'>
print(m2, type(m2))         # set() <class 'set'>
print(m3, type(m3))         # {'o', 'e', 'h', 'l'} <class 'set'>
print(m4, type(m4))         # {8, 9, 7} <class 'set'>

---

 

---

셋에는 문자열, 정수형, 실수형, 튜플형 데이터가 저장될 수 있습니다.
하지만 mutable한 값을 갖고있는 [list]의 경우에는 셋의 데이터가 될 수 없습니다.

#2. 셋에 저장되는 데이터
n = {10,"홍길동", (9,8,7)}
print(n, type(n))           # {10, (9, 8, 7), '홍길동'} <class 'set'>
print("="*50)

# n = {10,"홍길동", (9,8,7), [6,5,4]}  #리스트 삽입시에는 에러가 남 => 리스트 값이 mutable하기 때문
# print(n, type(n))

---

 

---

중복값을 저장할 수 없는 셋의 성질을 이용하여 리스트의 중복 값을 삭제하는 방법으로 사용 가능합니다.

#3. 중복된 리스트의 데이터 삭제 방법
x = [1, 2, 3, 3, 2, 6]
x2 = set(x)
print(x2)               # {1, 2, 3, 6}

---

 

---

셋 함수 내부에 있는 함수에 대해서 알아보도록 하겠습니다.

"""
Set 데이터에서 사용가능한 함수

# Set 함수 외부에서 가져온 함수
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__',
'__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__',
'__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__',
'__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 

# Set 함수 내부의 함수
'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection',
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 
'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

"""

---

 

---

1. (변수명).add(value)       ==> 데이터를 삽입합니다.
(데이터가 mutable한 [리스트] 데이터는 삽입 불가합니다.

#(1). add 함수를 이용한 데이터 삽입
m = {1, 2, 3}
print("기본 함수 :", m)         # 기본 함수 : {1, 2, 3}
m.add(4)
m.add("홍길동")
m.add((4,5))      # 튜플이 데이터로 add됨
# m.add([6,7])    # 리스트 add는 에러 -> mutable한 리스트 데이터는 셋의 데이터가 될 수 없음
print("1. add 함수:", m)       # 1. add 함수: {1, 2, 3, 4, '홍길동', (4, 5)}

 

2. (변수명).update(value)    ==> 데이터를 병합합니다.
([리스트] 데이터를 셋의 데이터에 병합 가능합니다. 리스트의 값을 immutable한 셋의 데이터로 병합합니다.)

#(2). update 함수를 이용한 데이터 병합
m = {9, 8, 7}
m.update({6,5})
m.update([4,3])   # 리스트의 데이터를 셋의 데이터에 병합시킴(update) -> immutable한 셋의 데이터로 병합
print("2. update 함수:", m)       # 2. update 함수: {3, 4, 5, 6, 7, 8, 9}

3. (변수명).discard(value)    ==> 데이터를 삭제합니다.
discard는 값이 존재하면 삭제하고, 값이 없으면 아무일도 일어나지 않습니다. (Error 없음)

#(3). discard 함수를 이용한 데이터 삭제
m = {9, 8, 7, 6, 5, 4}
m.discard(6)
m.discard(10)   # discard는 값이 존재하면 삭제, 값이 없으면 nothing (Error가 없다.)
print("3. discard로 삭제:", m)     # 3. discard로 삭제: {4, 5, 7, 8, 9}

 

4. (변수명).remove(value)    ==> 데이터를 삭제합니다.
remove는 값이 존재하면 삭제하고, 값이 없으면 Error를 발생합니다. ==> 예외 처리가 필요합니다.

#(4). remove 함수를 이용한 데이터 삭제
m = {9, 8, 7, 6, 5, 4}
m.remove(6)
# m.remove(10)   # remove는 값이 존재하면 삭제, 값이 없으면 Error 발생 ==> 예외처리 필요
print("4. remove로 삭제:", m)      #4. remove로 삭제: {4, 5, 7, 8, 9}

 

5. (변수명).pop(value)    ==>  데이터를 삭제합니다.
pop()함수는 데이터 값을 지정하지 않으면 맨 뒤의 값을 삭제해줍니다.
하지만 튜플은 순서가 없기 때문에 '뒤'라는 개념이 없어서 pop()을 사용하면 랜덤값을 삭제하게 됩니다. ===> 튜플에서 pop()은 잘 사용하지 않습니다.

#(5). pop 함수를 이용한 데이터 삭제  => 랜덤값 삭제 - 거의 사용하지 않는다.
m = {9, 8, 7, 6, 5, 4}
m.pop()
print("5. pop로 삭제:", m)         #5. pop로 삭제: {5, 6, 7, 8, 9}

 

6. (변수명).clear()    ==> 모든 데이터를 삭제합니다.        빈 셋은 set()으로 표현됩니다.

#(6). clear 함수를 이용한 데이터 삭제  => 전체 삭제
m = {9, 8, 7, 6, 5, 4}
m.clear()
print("6. clear로 삭제:", m)  #6. clear로 삭제: set()
print("=" * 50)              # => 빈 셋은 'set()'으로 표현된다. {}은 빈 딕셔너리

 

7. len(변수명)     ==> 셋의 길이를 확인합니다. (데이터 갯수 확인)

#(7). len 함수를 이용한 길이 확인
m = {9, 8, 7, 6, 5, 4}
print("7. len으로 길이 확인:", len(m))        # 7. len으로 길이 확인: 6

 

8. 멤버십 연산자를 이용하여 데이터 존재 여부를 확인합니다.
확인할 value in 변수명

#(8). 멤버십 연산자를 이용한 존재 여부 확인
m = {9, 8, 7, 6, 5, 4}
print("8. 멤버십 연산자:", 8 in m)
print("8. 멤버십 연산자:", 88 in m)

 

9. 집합 관련 함수 ( union(), intersection(), difference(), symmetric_difference() )

   가) 합집합        ==> A 변수명 .union(B 변수명)        # update()와 동일
   나) 교집합        ==> A 변수명 .intersection(B 변수명)
   다) 차집합        ==> A 변수명 .difference(B 변수명)
   라) 대칭 차집합 ==> A 변수명 .symmetric_difference(B변수명)  # 교집합을 제외한 나머지 값의 합, 각자 갖고 있는 값

#(9). 집합 관련 함수  ( union(), intersection(), difference(), symmetric_difference() )
a = {9, 8, 7, 6, 5, 4}
b = {1, 2, 3, 4, 5, 6}
print("9. 합집합:", a.union(b))    # update와 동일
print("10. 교집합:", a.intersection(b))
print("11. 차집합:", a.difference(b))
print("12. 대칭 차집합:", a.symmetric_difference(b))   # 교집합을 제외한 나머지, 각자 갖고 있는 것

 

10. 비트 연산자를 이용하여 집합 함수와 같은 효과를 낼 수 있다. ( |(and), &(and), ^(xor) ) + ( 산술 연산자 - )

& = and 연산, 둘 다 참일때만 만족
|   = or 연산, 둘 중 하나만 참이어도 만족
^ = xor 연산, 둘 중 하나만 참일 때 만족

#(10). 연산자를 이용하여 집합 관련 함수와 같은 효과를 낼 수 있다.
print("9. 합집합:", a | b)             # 9. 합집합: {1, 2, 3, 4, 5, 6, 7, 8, 9}
print("10. 교집합:", a & b)            # 10. 교집합: {4, 5, 6}
print("11. 차집합:", a - b)            # 11. 차집합: {8, 9, 7}
print("12. 대칭 차집합:", a ^ b)        # 12. 대칭 차집합: {1, 2, 3, 7, 8, 9}

---

셋 함수 정리를 마치고~
다음엔 집합형 데이터 마지막, 딕셔너리 정리를 하겠습니다.

그럼 이만~