파이썬 Dictionary

Dictionary은 말 그대로 사전처럼 인덱스(Key)를 기준으로 원하는 값을 찾기위해 사용.
다른 프로그램 언어(예: 자바스크립트)에서는 map이라고도 함.

{}를 사용하여 만들며 {키: 값} 형식으로 데이터를 저장. dict() Built-in 함수를 사용하여 만들 수도 있음.

key에는 mutable(예: list)한 타입은 사용할 수 없음(예: tuple은 사용가능)
value(값)에는 모든 type(예: list, dictionary, tuple) 사용 가능.

List와 다르게 데이터의 순서(sequence) 없음(list는 데이터를 넣은 순서대로 정렬되고 index를 이용하여 값을 찾음. Dictionary는 키를 이용하여 값을 찾기에 순서가 필요 없음)

Dictionary 만들기

>>> a = {}  # 빈 Dictionary 만들기
>>> a
{}
>>> type(a)
dict

>>> b = dict()  # 빑트인 함수를 사용하영 빈 Dictionary 만들기
>>> b
{}
>>> type(a)
dict

Dictionary 생성과 함께 아이템 추가하기

>>> fruits = {'a': 'apple'}  # Dictionary 생성과 함께 아이템 추가하기
>>> fruits
{'a': 'apple'}

>>> animals = dict(d='dogs', m='monkey')  # dict() 사용
>>> animals
{'d': 'dogs', 'm': 'monkey'}

# 다른 방법 들
>>> animals = dict([('d', 'dogs'), ('m', 'monkey')])

>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dict(zip(keys, values))
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> dict.fromkeys(['a', 'b'], 0)
{'a': 0, 'b': 0}
>>> dict.formkyes(['a', 'b'])  # 값을 정의하지 않으면 None
{'a': None, 'b': None}

Dictionary nesting

Dictionary 값에는 모든 오브젝트들(예: List, instance 등)이 들어갈 수 있음

>>> me = {'name': {'first': 'John', 'last': 'Doe'}, 'jobs': ['dev', 'mgr'], 'age': 50}

Dictionary에 아이템 추가하기

>>> fruits = {}
>>> fruites['a'] = 'apple'

Dictionary 값 가져오기

>>> D = {'a': 1, 'b': 2}
>>> D['a']
1

값이 없을 경우

KeyError를 발생

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D['d']
KeyError: 'f'

Nested Dictionary에서 값 가져 오기

>>> me = {'name': {'first': 'John', 'last': 'Doe'}, 'jobs': ['dev', 'mgr'], 'age': 50}
>>> me['name']
{'first': 'John', 'last': 'Doe'}  # 값이 Dictionary이기 때문에 Dictionary 반환
>>> me['name']['first']           # first name 반환
'John'
>>> me['jobs']                    # 값이 List이기 때문에 list 반환
['dev', 'mgr']
>>> me['jobs'][0]                 # 첫 번째 직업 반환
'dev'

Dictionary 값 변경

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D['a'] = 2
>>> D
{'a': 2, 'b': 1, 'c': 1}

Dictionary 아이템 제거

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> del D['a']
>>> D
{'b': 1, 'c': 1}

Dictionary 값 연산

# Integer 값 연산
>>> D = {'a': 1}
>>> D['a'] += 1
>>> D
{'a': 2}

# list 값 연산
>>> numeric = {'decimal': [1, 2, 3, 4, 5], 'float': [1.0, 2.0, 3.0, 4.0, 5.0]}
>>> numeric['decimal'].append(6)
>>> numeric
{'decimal': [1, 2, 3, 4, 5, 6], 'float': [1.0, 2.0, 3.0, 4.0, 5.0]}

Dictionary 키 set 연산

Dictionary 값은 set 연산을 할 수 없음

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D.keys() | {'d': 4}         # 합집합
{'a', 'b', 'c', 'd'}
>>> D.keys() & {'b': 1}         # 교집합
{'b'}
>>> D.keys() | {'b', 'c', 'd'}
{'b', 'c', 'a', 'd'}

>>> D.items() | {('c', 3), ('d', 4)}
{('a', 1), ('b', 2), ('c', 3), ('d', 4)}
>>> dict(D.items() | {('c', 3), ('d', 4)})
{'d': 4, 'c': 3, 'b': 2, 'a': 1}

Dictionary 메소드

.keys()

키를 반환.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.keys()
dict_keys(['a', 'b', 'c'])  # 인스턴스를 반환
>>> list(D.keys())          # list()를 이용하여 list로 생성
['a', 'b', 'c']

.values()

값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.values()
dict_values([1, 1, 1])  # 인스턴스를 반환
>>> list(D.values())    # list()를 이용하여 list로 생성
[1, 1, 1]
>>> tuple(D.values())   # tuple()을 이용하여 tuple로 생성

.items()

키와 값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.items()
dict_items([('a', 1), ('b', 1), ('c', 1)])  # 인스턴스를 반환
>>> list(D.items())                         # list()을 이용하여 list로 생성
[('a', 1), ('b', 1), ('c', 1)]

.get()

키에 해당하는 값을 반환하고, 키가 없을 경우 None을 반환하거나 정의한 값을 반환

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.get('a')
1
>>> print(D.get('d'))
None
>>> D.get('d', 0)
0

.update()

A Dictionary에 B Dictionary를 update 할 때 사용.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D2 = {'d': 1, 'e': 1}
>>> D.update(D2)
>>> D
{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1} 

(주의) B Dictionary에 A Dictionary와 같은 키가 있을 경우 B Dictionary에 있는 값으로 변경 됨.

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D2 = {'a': 2, 'b': 2}
>>> D.update(D2)
>>> D
{'a': 2, 'b': 2, 'c': 1}

.pop()

키에 해당하는 값을 반환하고 아이템을 제거. list의 pop() 메서드와 같음

>>> D = {'a': 1, 'b': 1, 'c': 1}
>>> D.pop('a')
1
>>> D
{'b': 1, 'c': 1}

Key 정렬하기(Sort)

어떤 경우 Dictionary의 키를 정렬할 필요가 있음(예를들어 사전 같은 경우 a~z 순으로 정렬).

>>> D = {'a': 1, 'c': 1, 'b': 1}
>>> keys = list(D.keys())
['a', 'c', 'b']
>>> keys.sort()            # list의 sort() 메서드 이용
['a', 'b', 'c']

>>> sorted(D):  # sorted() 빌트인 함수 이용
['a', 'b', 'c']

OrderedDict

list와 같이 아이템(키)을 넣은 순서대로 사용하고 싶을 때 사용.
사용법은 기본 dictionary와 같음

(주의) a~z와 같이 오름차순이나 내림차순으로 정렬하는 것이 아니라 Dictionary에 아이템을 넣은 순서를 기억하는 것임. 왜냐하면 dict()은 아이템을 넣은 순서를 기억하지 못하기 때문에 아이템이 들어간 순서를 기억하였다가 사용하고 싶을 때 사용.
오버헤드(성능저하) 있음.

>>> from collections import OrderedDict  # 빌트인이 아니기 때문에 import
>>> D = OrderedDict()  # OrderedDict 인스턴스 생성
>>> D 
OrderedDict()

또는
>>> D = OrderedDict(a=1)
>>> D
OrderedDict([('a', 1)])

# 아이템 추가
>>> D['b'] = 1
>>> D['a'] = 1
>>> D['c'] = 1
>>> D
OrderedDict([('b', 1), ('a', 1), ('c', 1)])

# 값 구하기
>>> D['b']
1

# 값 변경
>>> D['b'] = 2
>>> D
OrderedDict([('b', 2), ('a', 1), ('c', 1)])

# 아이템 제거
>>> del D['b']
>>> D
OrderedDict([('a', 1), ('c', 1)])

아이템을 정렬하여 넣고 싶을 때는 sorted()를 사용하면 됨.

>>> from collections import OrderedDict
>>> D = {'A': 2, 'C': 3, 'B': 1, 'E': 1, 'F': 2}
>>> OrderedDict(sorted(D.items())
OrderedDict([('A', 2), ('B', 1), ('C', 3), ('E', 1), ('F', 2)])  # key가 알파벳 순으로 정렬됨

Dictionary comprehensions

사용법은 list나 set comprehension과 같고 {}를 사용

>>> D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}

>>> D = {x: x ** 2 for x in range(5)}

>>> D = {x: x * 4 for x in 'PIZZA'}

>>> D = {x.lower(): x + '!' for x in ['PIZZA', 'HAMBURGER', 'TOAST]}

값에 해당하는 키 찾는 방법

>>> D = {1: 'a', 2: 'b', 3: 'c'}
>>> [key for (key, value) in D.items() if value == 'a']

KeyError 대비하기

if문 사용

if 'd' in D 구문을 사용하여 해당 키(d) 유무 확인.
키가 있으면 True, 없으면 False를 반환

if 'd' in D:
    print(D['d'])
else:
    print(0)

try문 사용

예외처리 하면 된다.

try:
    print(D['d'])
except KeyError:
    print(0)

.get() 메소드 사용

KeyError를 발생시키지 않음

>>> value = D.get('d')  # 키가 없으면 None을 리턴
>>> value
None

>>> D.get('d', 0)  # 키가 없으면 대체 값을 리턴
0

for문과 사용

for문을 사용하면 키나 값을 가져올 때 list로 변환 할 필요 없음.

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> for key in D:  # 키가 사용됨. D.keys()와 같음.
        print(key)

>>> for value in D.values():
        print(value)

>>> for item in D.items():  # item은 Tuple 형태
        print(item)

>>> for key, value in D.items():
        print(key, value)

>>> for key in D:
        print(key, D[key])