6. 딕셔너리, 세트

'''
문자열 함수
집합형 자료형 
- 리스트(CRUD) []
- 튜플(CR,U-insert만 가능,D-전체삭제만가능) ()
- 딕셔너리(CUD, R-키인덱싱만 가능) {키: 값 ...}
- 집합(CUD) {} : 집합은 순서가 없으므로 Read 안됨, 수학과비슷// 리스트와 딕셔너리가 중요. 
- Read : 인덱싱, 슬라이싱

'''

 

1. 딕셔너리

# Create
# 딕셔너리 생성 1 - 초기값 지정방식
# {키1:값1, 키2:값2 ...} -> 키 값은 보통 문자열로 사용/숫자도 가능하긴 함
# 키는 중복허용되지 않는다.
dict1 = {'a':'apart', 'b':'banana', 'c':'cat'}
print(dict1,len(dict1), type(dict1)) 
# {'a': 'apart', 'b': 'banana', 'c': 'cat'} 3 <class 'dict'>
dict1 = {'a':'apart', 'b':'banana', 'c':'cat', 'a':'apple', 'c1':'cat'}
print(dict1,len(dict1), type(dict1)) 
#{'a': 'apple', 'b': 'banana', 'c': 'cat', 'c1': 'cat'} 4 <class 'dict'> 
# 즉, 키가 중복되어 'a'는 나중에 나온 apple로 출력 또한 값은 중복될 수 있다.


# 딕셔너리 생성 2 - 빈 딕셔너리 생성 후 데이터 추가 
# 딕셔너리명[키] = 값
# 키가 기존 딕셔너리에 있다면 값 수정
# 키가 기존 딕셔너리에 없다면 데이터 추가
dict2 = {}
print(dict2, len(dict2), type(dict2)) #{} 0 <class 'dict'>
dict2['가'] = '가로수'
dict2['나'] = '나무'
dict2['다'] = '다리미'
print(dict2, len(dict2), type(dict2)) #{'가': '가로수', '나': '나무', '다': '다리미'} 3 <class 'dict'>
dict2['나'] = '나일강' # 수정
print(dict2, len(dict2), type(dict2)) #{'가': '가로수', '나': '나일강', '다': '다리미'} 3 <class 'dict'>

# 딕셔너리 인덱싱 하려면 키 값 입력 / 위치 인덱싱 불가 / 슬라이싱 불가

# Read - 딕셔너리명[키] : 키 인덱싱
dict3 = {'a':'apart', 'b':'banana', 'c':'cat'}
print(dict3['b']) #banana
print(f" b키의 값은? {dict3['b']} ") # b키의 값은? banana
# print(f" b키의 값은? {dict3[1]} ") #KeyError: 1 // 1이란 해당키가 없기때문
# 즉, 위치값으로는 불가능


# Update
# 딕셔너리명[기존키] = 값 -> 수정(단일수정)
# 딕셔너리명.update(키1=값1, 키2=값2 ... ) : 키는 문자열키만 해당하고 키는 인용부호 없이 변수 형태로 지정
dict4 = {'a':'apart', 'b':'banana', 'c':'cat'}
dict4['a'] = 100
print(dict4) #{'a': 100, 'b': 'banana', 'c': 'cat'}
dict4.update( a='강아지', b='도라지') #if 'b'='도라지'라 하면 syntax 에러 발생
print(dict4) #{'a': '강아지', 'b': '도라지', 'c': 'cat'} #구분할땐 키값에 인용부호 안씀

# Delete
# 딕셔너리명.pop(키) : 키에 해당하는 데이터 삭제  -> 프린트문 안에서 가능
# del 딕셔너리명[키] : 키에 해당하는 데이터 삭제 -> 프린트문 안에서 불가능
# 딕셔너리명.clear() => 빈 딕셔너리로 반환 {}
# del 딕셔너리명 => 딕셔너리 삭제

dict5 = {'a':'apart', 'b':'banana', 'c':'cat', 'd':'dress'}
dict5.pop('a')
print(dict5) #{'b': 'banana', 'c': 'cat', 'd': 'dress'}
# print('삭제하려는 데이터', dict5.pop('a')) 입력하면 결과는 #삭제하려는 데이터 apart
# 즉, pop()은 print()문 안에 사용 가능
del dict5['c']
print(dict5) #{'b': 'banana', 'd': 'dress'}
dict5.clear()
print(dict5) #{}
# del dict5
# print(dict5) #NameError

# 딕셔너리 키 조합, 값 조합 함수들
# values() => [값1, 값2 ....]
# keys() => [키1, 키2 ....]
# items() => [(키1,값1),(키2,값2)....] => 튜플 스타일로 나옴
# popitem() => (마지막키, 마지막값) 반환되면서 삭제

dict6 = {'a':'apart', 'b':'banana', 'c':'cat', 'd':'dress'}
value_list = dict6.values()
print(value_list, type(value_list)) #dict_values(['apart', 'banana', 'cat', 'dress']) <class 'dict_values'>
value_list = list(dict6.values())
print(value_list, type(value_list)) #['apart', 'banana', 'cat', 'dress'] <class 'list'>
key_list = list(dict6.keys()) #키만 추출
print(key_list, type(key_list)) #['a', 'b', 'c', 'd'] <class 'list'>
item_list = list(dict6.items()) #리스트안의 (키, 값) 튜플 형태로 추출
print(item_list, type(item_list)) #[('a', 'apart'), ('b', 'banana'), ('c', 'cat'), ('d', 'dress')] <class 'list'>
print('딕셔너리의 마지막 키와 값 : ', dict6.popitem()) #딕셔너리의 마지막 키와 값 :  ('d', 'dress')
print(dict6) #{'a': 'apart', 'b': 'banana', 'c': 'cat'}
print('딕셔너리의 마지막 키와 값 : ', dict6.popitem()) #딕셔너리의 마지막 키와 값 :  ('c', 'cat')
print(dict6) #{'a': 'apart', 'b': 'banana'}

 

2. 세트 

# 집합 자료형 (Read 없음)
# Create
# {값1, 값2, ....}
# set(리스트|튜플|딕셔너리|문자열)
# 빈집합은 set()

set1 = { 100, 200, 300, 'Hello', True }
print(set1, type(set1), len(set1)) 
#{True, 100, 200, 300, 'Hello'} <class 'set'> 5
# 집합은 순서가 없는 데이터형, 출력할때마다 무작위로 출력된다. 따라서 인덱싱과 슬라이싱 불가능
# 리스트,튜플,문자열 => 집합
mylist = ['안유진', '장원영', '리즈', '이서']
mytuple = (100, 200, 300)
mytext = '가나다라마바사'
print(set(mylist)) #{'이서', '안유진', '리즈', '장원영'}
print(set(mytuple)) #{200, 100, 300}
print(set(mytext)) #{'바', '나', '다', '가', '마', '라', '사'} => 문자열은 분리됨
#빈 집합은?
set2 = set()
set3 = {}
print(set2, type(set2)) #set() <class 'set'>
print(set3, type(set3)) #{} <class 'dict'>

# 집합은 중첩 데이터를 허용하지 않는다.
set4 = { 100, 200, 300, 'Hello', True, True, True, False, 200, 200}
print(set4) #{False, True, 100, 200, 300, 'Hello'} 

# Update
# 데이터 추가 - add(데이터), update([데이터1, 데이터2 ...])

# Delete
# remove(데이터) , clear()
# del 집합명

set5 = set() #빈 집합 생성
set5.add('장화')
set5.add('피노키오')
set5.add('신데렐라')
print(set5, len(set5)) #{'신데렐라', '피노키오', '장화'} 3
set5.update([100, 200])
print(set5, len(set5)) #{100, 200, '피노키오', '장화', '신데렐라'} 5
set5.update((True, False)) #튜플 형태로 추가
print(set5, len(set5)) #{False, True, '신데렐라', 100, '장화', 200, '피노키오'} 7
set5.update({'a':'apart', 'b':'bed'}) #딕셔너리 형태로 추가 => 키가 데이터로 추가됨
print(set5, len(set5)) #{False, True, '신데렐라', 'a', 100, 'b', '장화', 200, '피노키오'} 9
# 문자열 추가 => 낱 글자로 분리되어서 데이터로 추가
set5.update('도레미')
print(set5, len(set5))
#{'장화', True, '피노키오', False, 100, 'b', 200, '레', '신데렐라', 'a', '미', '도'} 12
# 데이터 값으로 삭제
set5.remove(True)
set5.remove(False)
print(set5, len(set5)) 
#{100, 200, '레', '도', '장화', 'a', '피노키오', 'b', '신데렐라', '미'} 10
set5.clear()
print(set5, len(set5)) #set() 0
# 아래의 집합에서 3 대신 30을 데이터로 삽입하고 싶다면?
# 결과 => 순서 상관없이 {1, 2, 30, 4, 5}
# 내풀이
# set6 = {1, 2, 3, 4, 5}
# set6.remove(3)
# set6.add(30)
# print(set6)
#해설
set6 = {1, 2, 3, 4, 5}
print(f" Before : {set6}") # Before : {1, 2, 3, 4, 5}
set6.remove(3)
set6.add(30)
print(f" After : {set6}") # After : {1, 2, 4, 5, 30}

# 집합 연산을 위한 연산자와 함수
# 합집합 : |(파이프) , 집합변수명1.union(집합변수명2)
# 차집합 : -(마이너스) , 집합변수명1.difference(집합변수명2)
# 교집합 : &(doavjtosem(ampersand)) , 집합변수명1.intersection(집합변수명2)
# 대칭차집합 : ^(캐럿(caret)) , 집합변수명1.symmetric_difference(집합변수명2) => 합집합 결과에서 교집합 결과 제외

print('='*30)

set1 = {'최', '박', '선우', '김', '이'}
set2 = {'신', '장', '윤', '김', '이'}
# 합집합
print( set1|set2) #{'박', '이', '선우', '장', '신', '윤', '최', '김'}
print( set1.union(set2)) #{'박', '이', '선우', '장', '신', '윤', '최', '김'}
# 차집합
print( set1-set2) #{'박', '최', '선우'}
print( set1.difference(set2)) #{'박', '최', '선우'}
#교집합
print( set1&set2) #{'이', '김'}
print( set1.intersection(set2)) #{'이', '김'}
#대칭차집합
print( set1^set2) #{'신', '박', '선우', '최', '윤', '장'}
print( set1.symmetric_difference(set2)) #{'신', '박', '선우', '최', '윤', '장'}

# Quiz
# 1)리스트변수 정의
# 2) 리스트를 집합으로 변경 : 중복값 삭제 용도
# 3) 집합을 다시 리스트로 변경한 후 정렬 함수 이용(내림차순)
# reverse(), 리스트명.sort(reverse=True)
# sorted(리스트명, reverse=True)
# 4) 출력
# number_list에서 중복 숫자를 제거한 후 내림차순 형태로 정렬하여라
# number_list = [ 5, 1, 2, 2, 3,4, 5, 6, 7, 6, 7, 8, 9, 9, 10, 10 ]
# 예시)
# Before : [5, 1, 2, 2, 3, 4, 5, 6, 7, 6, 7, 8, 9, 9, 10, 10]
# After : [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

number_list = [ 5, 1, 2, 2, 3,4, 5, 6, 7, 6, 7, 8, 9, 9, 10, 10 ]
set7 = set(number_list)
print(f" Before : {number_list}")
kk = list(set7)
kk.sort(reverse=True)
print(f" After : {kk}")

#해설

print(f" Before : {number_list}")
number_list = list(set(number_list))
number_list.reverse()
print(f" After : {number_list}")