[파이썬] 딕셔너리 key : value를 사용하자

enumerate( )

인덱스와 아이템을 한번에 조회할 수 있는 함수

 

리스트에서 사용

food = ['떡볶이', '순대', '어묵', '튀김']

for index, value in enumerate(food) :
    print(f'{index} : {value}')
    
출력
0 : 떡볶이
1 : 순대
2 : 어묵
3 : 튀김

 

str = '떡볶이는 맛있다.'

for index, value in enumerate(str) :
    print(f'{index} : {value}')

출력
0 : 떡
1 : 볶
2 : 이
3 : 는
4 :
5 : 맛
6 : 있
7 : 다
8 : .

 

 

---

딕셔너리

키와 밸류를 이용해서 자료를 관리

 

[키] 통해서 값 접근

 - 없는 키값 요청시 에러 발생

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food['f0'])           #키를 통해서 밸류 접근
print(food['f1'])

print(food['f3'])           #키를 통해서 밸류 리스트 전체 접근
print(food['f3'][0])        #키를 통해서 밸류 리스트의 인덱스의 값 접근
print(food['f3'][1])


출력
떡볶이
순대
['오징어튀김', '고추튀김']
오징어튀김
고추튀김

 

.get(키) 통해서 값 접근

 - 없는 키값을 요청해도 에러 발생하지 않음(None 반환)

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food.get('f0'))           #get(키)를 통해서 밸류 접근
print(food.get('f1'))

print(food.get('f3'))           #get(키)를 통해서 밸류 리스트 전체 접근
print(food.get('f3')[0])        #get(키)를 통해서 밸류 리스트 전체 접근
print(food.get('f3')[1])        #get(키)를 통해서 밸류 리스트 전체 접근

print(food.get('f4s'))          #get(키)를 통해서 없는 키 접근


출력
떡볶이
순대
['오징어튀김', '고추튀김']
오징어튀김
고추튀김
None

 

get을 통해서 키 생성, 키의 개수를 값으로 개수 세기

dic.get(키로쓴값, 초기개수) + 1

food = [["분식", "떡볶이"], ["분식", "떡볶이"], ["식사", "짜장면"], ["식사", "돈까스"], ["후식", "아이스크림"]]

dic = {}

for type, item in food :
	dic[item] = dic.get(item, 0) + 1        #dic.get(키로 쓴 값, 초기 개수) + 1
print(dic)

 

.keys( )

 - 키만 접근

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food.keys())           #키만 뽑아서 반환
print(type(food.keys()))     #타입은 딕셔너리 키


출력
dict_keys(['f0', 'f1', 'f2', 'f3'])
<class 'dict_keys'>

 

.values( )

 - 값만 접근

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food.values())            #키만 뽑아서 반환
print(type(food.values()))      #키만 뽑아서 반환


출력
dict_values(['떡볶이', '순대', '어묵', ['오징어튀김', '고추튀김']])
<class 'dict_values'>

 

.itmes( )

 - 키와 밸류가 튜플로 저장되어 반환

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food.items())           #키만 뽑아서 반환
print(type(food.items()))     #타입은 딕셔너리 키
print(list(food.items()))     #리스트로 변환


출력
dict_items([('f0', '떡볶이'), ('f1', '순대'), ('f2', '어묵'), ('f3', ['오징어튀김', '고추튀김'])])
<class 'dict_items'>
[('f0', '떡볶이'), ('f1', '순대'), ('f2', '어묵'), ('f3', ['오징어튀김', '고추튀김'])]

 

keys(), values(), items() 반복문으로 접근

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print("--key 조회--")
for key in food.keys() :
    print(key)

for index, key in enumerate(food.keys()) :
    print("index :", index, " / ", "key :", key)


print("--value 조회--")
for value in food.values() :
    print(value)

for index, value in enumerate(food.values()) :
    print("index :", index, " / ", "value :", value)


print("--아이템 조회--")
for item in food.items() :
    print(item)

for index, item in enumerate(food.items()) :
    print("index :", index, " / ", "item :", item)
    
출력    
--key 조회--
f0
f1
f2
f3
index : 0  /  key : f0
index : 1  /  key : f1
index : 2  /  key : f2
index : 3  /  key : f3

--value 조회--
떡볶이
순대
어묵
['오징어튀김', '고추튀김']
index : 0  /  value : 떡볶이
index : 1  /  value : 순대
index : 2  /  value : 어묵
index : 3  /  value : ['오징어튀김', '고추튀김']

--아이템 조회--
('f0', '떡볶이')
('f1', '순대')
('f2', '어묵')
('f3', ['오징어튀김', '고추튀김'])
index : 0  /  item : ('f0', '떡볶이')
index : 1  /  item : ('f1', '순대')
index : 2  /  item : ('f2', '어묵')
index : 3  /  item : ('f3', ['오징어튀김', '고추튀김'])

 

for in으로 key 접근

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김']}

for item in food :
    print(item)
    
    
출력
f0
f1
f2

 

del 딕셔너리[키]

 - 딕셔너리 삭제

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food)
del food['f2']
print(food)


출력
{'f0': '떡볶이', 'f1': '순대', 'f2': '어묵', 'f3': ['오징어튀김', '고추튀김']}
{'f0': '떡볶이', 'f1': '순대', 'f3': ['오징어튀김', '고추튀김']}

 

.pop(키)

 - 삭제된 값을 반환

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print(food)
pop_value = food.pop('f2')
print(food)
print(pop_value)            #삭제된 값을 반환


출력
{'f0': '떡볶이', 'f1': '순대', 'f2': '어묵', 'f3': ['오징어튀김', '고추튀김']}
{'f0': '떡볶이', 'f1': '순대', 'f3': ['오징어튀김', '고추튀김']}
어묵

 

keys(), values(), items() 반복문을 통해서 특정 값 찾기

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

#키순환을 통해 특정 키:밸류 찾기
print('--순환을 통해 특정 키:밸류 찾기--')
for key in food.keys() :
    if food[key] == '순대' :        
        print('key :',key, 'value', food[key])

#밸류 순환을 통해서 특정 키:밸류 찾기
print('--밸류 순환을 통해서 특정 키:밸류 찾기--')
for value in food.values() :
    if value == '어묵' :
        print('key :',key, 'value', food[key])

#items 순환을 통해서 리스트로 접근해서 키:밸류 찾기
print('--items 순환을 통해서 리스트로 접근해서 키:밸류 찾기--')
for item in food.items() :
    print("key :", item[0])
    print("value :", item[1])
    
    if item[1] == '어묵' :
        print("어묵 찾았다 =>",'key :', item[0], 'value', item[1])
    
    
출력   
--순환을 통해 특정 키:밸류 찾기--
key : f1 value 순대

--밸류 순환을 통해서 특정 키:밸류 찾기--
key : f3 value ['오징어튀김', '고추튀김']

--items 순환을 통해서 리스트로 접근해서 키:밸류 찾기--
key : f0
value : 떡볶이
key : f1
value : 순대
key : f2
value : 어묵
어묵 찾았다 => key : f2 value 어묵
key : f3
value : ['오징어튀김', '고추튀김']

 

key in 딕셔너리

 - 키(key) 있음 파악

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print('f2' in food)         #있는 키 요청
print('f100' in food)       #없는 키 요청

출력
True
False

 

key not in 딕셔너리

 - 키(key) 없음 파악

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김']}

print('f2' not in food)         #있는 키 요청
print('f100' not in food)       #없는 키 요청


출력
False
True

 

 

len(딕셔너리)

 - 딕셔너리 길이 구하기

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김']}

print(len(food))           #전체 딕셔너리의 개수
print(len(food['f3']))     #키가 f3인 아이템의 개수

출력
4
3

 

 

in, not in으로 key, values 찾기

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김']}

print("--for in으로 key 찾기--")
for item in food :
    if  'f2' == item :
        print("key :", item, "value :", food[item])
        break

print("--keys()로 key 찾기--")
for key in food.keys() :
    if 'f2' in key:
        print("key :", key, "value :", food[key])
        break

print("--itmes()로 key 찾기--")
for item in food.items() :
    if 'f2' in item[0] :
        print("key :", item, "value :", food[item[0]])
        break

print("not in으로 key 찾기--")
for key in food.keys() :
    if 'f100' not in key:
        print("없음")
        break
        

출력
--for in으로 key 찾기--
key : f2 value : 어묵

--keys()로 key 찾기--
key : f2 value : 어묵

--itmes()로 key 찾기--
key : ('f2', '어묵') value : 어묵

not in으로 key 찾기--
없음

 

딕셔너리에서 find 리스트에 있는 값을 이용해서 키 찾기

food = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김'], 'f4':'칠리탕수육', 'f5' : '피카츄돈까스'}
find_list = ['f2', 'f4']        #찾으려 하는 키 리스트

for find in find_list :         #찾으려 하는 키 리스트 순회
    if find in food :           #food 리스트에 find가 있으면 
        print(food[find])       #food[find] 밸류 출력
  
  
출력
어묵
칠리탕수육

 

공통 키에 값 여러개 추가하기

 - 값이 리스트로 되어있어야 다수 밸류 추가 가능

food = {'f0' : '떡볶이', 'f1' : '순대'}
food['f1'] = ['순대']       #item을 리스트로 변경줘야 리스트로 추가 가능
food['f1'].append("튀김")
food['f1'].append("어묵")

print(food)


출력
{'f0': '떡볶이', 'f1': ['순대', '튀김', '어묵']}

 

+를 통해 해당 딕셔너리 키에 리스트 추가

food = {'떡볶이': [], '순대': []}
food['떡볶이'] += [1,3]
food['순대'] += [4,6]
print(food)


출력
{'떡볶이': [1, 3], '순대': [4, 6]}

 

 

중복값이 있는 리스트에 키가 없으면 키 생성, 키 있으면 개수 세기

 - 리스트에 있는 알파벳의 개수 세기

#alpah 내부에 있는 알파벳 카운트
alpha_list = ['a','b','c','d','d','e','e','f','g','b','h','i','j','b','k']
result = {}

for alpha in alpha_list :
    if alpha not in result :        #키가 없으면 키 생성, 값은 1개
        result[alpha] = 1
    else :                          #키가 이미 있으므로 개수 += 1
        result[alpha] = result[alpha] + 1

print(result)

출력
{'a': 1, 'b': 3, 'c': 1, 'd': 2, 'e': 2, 'f': 1, 'g': 1, 'h': 1, 'i': 1, 'j': 1, 'k': 1}

 

 - food에 떡볶이, 어묵이 중복으로 들어가 있음

 - 이를 포함해서 리스트의 값을 개수를 세서 딕셔너리로 만든다

dic = {'리스트 값' : '리스트 값 개수'}

food = ['떡볶이', '떡볶이', '순대', '어묵', '어묵', '튀김']
dic = {}

for key in food : 
    if key not in dic.keys() :          #키가 없으면 키 생성 및 개수는 1
        dic[key] = 1
    else :                              #키가 있으면 키가 찾아진 개수만큼 누적 +=1
        dic[key] += 1

print(dic)


출력
{'떡볶이': 2, '순대': 1, '어묵': 2, '튀김': 1}

 

중복값이 있는 리스트에 키가 없으면 키 생성, 키 있으면 키의 값 리스트로 추가

리스트에 있는 값을 키, 밸류 리스트,

중복있는 값도 밸류 리스트로 추가

dic = {키1 : [값1, 값2],

        키2 : [값3]}

food = ['떡볶이', '떡볶이', '순대', '어묵', '어묵', '튀김']
dic = {}

for key in food :
    print(key)

for key in food : 
    if key not in dic.keys() :          #키가 없으면 키 생성 및 개수는 1
        dic[key] = [key]
    else :                              #키가 있으면 키가 찾아진 개수만큼 누적 +=1
        dic[key].append(key)

print(dic)


출력
{'떡볶이': ['떡볶이', '떡볶이'], '순대': ['순대'], '어묵': ['어묵', '어묵'], '튀김': ['튀김']}

 

 

딕셔너리 아이템에 딕셔너리, 리스트 접근

 - 딕셔너리 내부에 있는 딕셔너리와, 리스트를 type을 통해서 접근(딕셔너리 : dict, 리스트 : list)

food = {
    'name': '떡볶이',
    'price': '12000',
    'spicy': {                                      # item type은 dict
        '1단계': '안매운맛',
        '2단계': '중간맛',
        '3단계': '매운맛'
    },
    'topring': ['당면','소시지', '계란']            # skill tpye은 리스트
}

for key in food:
    if type(food[key]) is dict:     # 딕셔너리 타입 아이템
        for k in food[key]:
            print(k, ":" , food[key][k])

    elif type(food[key]) is list:   # 리스트 타입
        for item in food[key]:
            print(key, ":", item)

    else: 							# 일반 딕셔너리 아이템
        print(key, ":", food[key])
      
      
출력
name : 떡볶이
price : 12000
1단계 : 안매운맛
2단계 : 중간맛
3단계 : 매운맛
topring : 당면
topring : 소시지
topring : 계란

 

기존 딕셔너리에 중복된 키 빼고 이어서 추가

 - foo1에 food2 추가(단 중복된 key는 제외)

기존dic = {'키' : ['값1', '값2', '값3'],

             {'키' : '값4', '값5', ['값6', '값7']}

             {'신규키' : '값8',

             {'신규키' : '값9'}

food1 = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김'], 'f4':'칠리탕수육', 'f5' : '피카츄돈까스'}
food2 = {'f1' : '순대', 'f4':'칠리탕수육', 'f11': '김밥', 'f12':'주먹밥'}

print(food1)
print(food2)

for key, value in food2.items() :
    if key not in food1 :
        food1[key] = value

print(food1)

출력
{'f0': '떡볶이', 'f1': '순대', 'f2': '어묵', 'f3': ['오징어튀김', '고추튀김', '어묵튀김'], 'f4': '칠리탕수육', 'f5': '피카츄돈까스'}
{'f1': '순대', 'f4': '칠리탕수육', 'f11': '김밥', 'f12': '주먹밥'}
{'f0': '떡볶이', 'f1': '순대', 'f2': '어묵', 'f3': ['오징어튀김', '고추튀김', '어묵튀김'], 'f4': '칠리탕수육', 'f5': '피카츄돈까스', 'f11': '김밥', 'f12': '주먹밥'}

 

 

공통된 딕셔너리 key로 다수의 value 리스트를 갖기 위래 value 리스트로 추가

 - 새로운 키:밸류, 중복 키:밸류가 있는 foo1, food2 딕셔너리 있음

 - 이를 합쳐서 새로운 딕셔너리 생성

 - 한 키에서 여러개의 값을 갖기 위해서 value는 리스트

dic = {'키' : ['값1', '값2', '값3'],

        {'키' : '값4', '값5', ['값6', '값7']}

food1 = {'f0' : '떡볶이', 'f1' : '순대', 'f2' : '어묵', 'f3' : ['오징어튀김', '고추튀김', '어묵튀김'], 'f4':'칠리탕수육', 'f5' : '피카츄돈까스'}
food2 = {'f0' : '떡볶이', 'f1' : '순대', 'f4':'칠리탕수육', 'f11': '김밥', 'f12':'주먹밥'}
dic = {}

print(food1)
print(food2)

for key, value in food1.items() :
    if key not in dic :
        dic[key] = [value]
    else :
        dic[key].append(value)

for key, value in food2.items() :
    if key not in dic :
        dic[key] = [value]
    else :
        dic[key].append(value)

print(dic)


출력
{'f0': '떡볶이', 'f1': '순대', 'f2': '어묵', 'f3': ['오징어튀김', '고추튀김', '어묵튀김'], 'f4': '칠리탕수육', 'f5': '피카츄돈까스'}
{'f0': '떡볶이', 'f1': '순대', 'f4': '칠리탕수육', 'f11': '김밥', 'f12': '주먹밥'}
{'f0': ['떡볶이', '떡볶이'], 'f1': ['순대', '순대'], 'f2': ['어묵'], 'f3': [['오징어튀김', '고추튀김', '어묵튀김']], 'f4': ['칠리탕수육', '칠리탕수육'], 'f5': ['피카츄돈까스'], 'f11': ['김밥'], 'f12': ['주먹밥']}

 

 

딕셔너리 정렬

dic = {'a': 5, 'x': 2, 'd': 3, 'c': 1, 'f': 1, 'e': 0}

sort_dic = sorted(dic.items())
print(sort_dic)
#딕셔너리 키 정렬
#[('a', 5), ('c', 1), ('d', 3), ('e', 0), ('f', 1), ('x', 2)]

sort_dic = sorted(dic.items(), key=lambda x: -x[1])
print(sort_dic)
#아이템[1번]으로 내림차순 정렬(-)
#[('a', 5), ('d', 3), ('x', 2), ('c', 1), ('f', 1), ('e', 0)]

sort_dic = sorted(dic.items(), key=lambda x: x[1])
print(sort_dic)
#아이템[1번]으로 오름차순 정렬(+)
#[('e', 0), ('c', 1), ('f', 1), ('x', 2), ('d', 3), ('a', 5)]

sort_dic = sorted(dic.items(), key=lambda x: (x[1], x[0]))
print(sort_dic)
#아이템[1번]으로 오름차순 정렬 and 같은 경우 키[0번]으로 오름차순 정렬 

sort_dic = sorted(dic.items(), key=lambda x: (-x[1], x[0]))
print(sort_dic)
#아이템[1번]으로 내림차순 정렬 and 같은 경우 키[0번]으로 내림차순 정렬 


sort_dic = sorted(dic.items(), key=lambda x: (x[1], x[0]), reverse=True)
print(sort_dic)
## sorted의 reverse는 기본적으로 False(오름차순)이기 때문에 reverse(내림차순)
#아이템[1번]으로 오름차순 정렬 and 같은 경우 키[0번]으로 오름차순 정렬

 

키를 만들고, 개수를 센 다음, 밸류로 오름차순, 키로 내림차순 정렬

food = ['감자튀김','떡볶이', '떡볶이', '떡볶이', '순대', '어묵', '어묵', '어묵','어묵', '튀김']
dic = {}

for key in food : 
    if key not in dic.keys() :          #키가 없으면 키 생성 및 개수는 1
        dic[key] = 1
    else :                              #키가 있으면 키가 찾아진 개수만큼 누적 +=1
        dic[key] += 1

print(dic)


#1번 밸류로 오름차순 정렬, #같은 경우, 0번으로 내림차순 정렬 
sort_dic = sorted(dic.items(), key=lambda x: (x[1], -x[0])) 
print(sort_dic)


출력
{'감자튀김': 1, '떡볶이': 3, '순대': 1, '어묵': 4, '튀김': 1}
[('감자튀김', 1), ('순대', 1), ('튀김', 1), ('떡볶이', 3), ('어묵', 4)]

#같은 경우 (ㄱ, ㅅ, ㅌ) 순서