딕셔너리란?

• Key(고유한 값)와 Value를 한 쌍으로 갖는 자료형
• 리스트나 튜플처럼 순차적으로 해당 요솟값을 구하지 않고 Key를 통해 Value를 얻는다

a = {1: 'hi', 2: 'hello'}
a #{1: 'hi', 2: 'hello'}

접근, 추가

a[1] #'hi'
a['this'] #is appended value

리스트나 튜플, 문자열은 요솟값을 얻고자 할 때 인덱싱이나 슬라이싱을 했다.
그러나 딕셔너리는 요소에 접근하기 위해 [] 안에 인덱스 번호가 아닌 key값 자체가 들어간다.

a['this'] = 'is appended value'
a['new'] = [1,2,3]
a #{1: 'hi', 2: 'hello', 'this': 'is appended value', 'new': [1, 2, 3]}

Key로 문자열 'this', Value로 문자열 'is appended value' 을 추가하였다.
또 Value에 리스트도 넣을 수 있음을 확인하였다.

a[1] = 'new appended value'
a #{1: 'new appended value', 2: 'hello', 'this': 'is appended value'}

또 딕셔너리의 키가 중복될 때에는 마지막 값으로 덮어씌워진다.
즉 앞의 1:'hi'가 삭제된 것.

삭제

del a['new']
a #{1: 'hi', 2: 'hello', 'this': 'is appended value'}

삭제는 del a[key]을
입력하면 지정한 Key에 해당하는 {key : value} 쌍이 삭제된다.

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
x.pop('a') #10
x #{'b': 20, 'c': 30, 'd': 40}

pop은 del과 달리 삭제와 동시에 삭제된 값을 반환한다.

x.pop('f',90) #90

또 pop(키, 기본값)처럼 기본값을 지정하면
딕셔너리에 키가 있을 때는 해당 키-값 쌍을 삭제한 뒤 삭제한 값을 반환하지만 키가 없을 때는 기본값만 반환한다

x.popitem() #('d', 40) #3
x #{'b': 20, 'c': 30}

popitem()은 딕셔너리에서

파이썬 3.6 이상: 마지막 키-값 쌍을 삭제
3.5 이하: 임의의 키-값 쌍을 삭제하고

삭제한 키-값 쌍을 튜플로 반환한다.
파이썬 3.5 이하에서는 매번 삭제하는 키-값 쌍이 달라진다.

clear()는 딕셔너리 안의 모든 요소를 삭제한다.

a.clear() 

key, value의 데이터 타입

• 딕셔너리의 키로 사용할 수 있는 자료형은 변경 불가능한(immutable) 자료형
• 즉 int, float, str, tuple 등
• 리스트는 변경가능한 값이므로 key에 올 수 없다.
• 단, Value에는 변하는 값이든 변하지 않는 값이든 상관없이 아무 값이나 넣을 수 있다.

# 정수 키
int_key_dict = {}
int_key_dict[1] = "one"
int_key_dict[2] = "two"
print("Integer keys:", int_key_dict)

# 실수 키
float_key_dict = {}
float_key_dict[1.0] = "one point zero"
float_key_dict[2.5] = "two point five"
print("Float keys:", float_key_dict)

# 문자열 키
str_key_dict = {}
str_key_dict["one"] = 1
str_key_dict["two"] = 2
print("String keys:", str_key_dict)

# 튜플 키
tuple_key_dict = {}
tuple_key_dict[(1, 2)] = "one and two"
tuple_key_dict[(3, 4)] = "three and four"
print("Tuple keys:", tuple_key_dict)

# Integer keys: {1: 'one', 2: 'two'}
# Float keys: {1.0: 'one point zero', 2.5: 'two point five'}
# String keys: {'one': 1, 'two': 2}
# Tuple keys: {(1, 2): 'one and two', (3, 4): 'three and four'}

dict = {
    "integer": 1,
    "float": 1.5,
    "string": "hello",
    "tuple": (1, 2, 3),
    "list": [4, 5, 6],
    "dictionary": {"a": 1, "b": 2},
    "set": {1, 2, 3}
}

for key, value in dict.items():
    print(f"{key}: {value} (type: {type(value)})")

# integer: 1 (type: <class 'int'>)
# float: 1.5 (type: <class 'float'>)
# string: hello (type: <class 'str'>)
# tuple: (1, 2, 3) (type: <class 'tuple'>)
# list: [4, 5, 6] (type: <class 'list'>)
# dictionary: {'a': 1, 'b': 2} (type: <class 'dict'>)
# set: {1, 2, 3} (type: <class 'set'>)

딕셔너리 관련 함수들

keys(), values(), items()

• 이 함수를 통해 리턴되는 객체는 뷰 객체(view objects)
• 딕셔너리의 내용이 변경되면 뷰 객체도 변경사항을 반영
  (when the dictionary changes, the view reflects these changes)

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}

라는 딕셔너리가 있다고 하자.

이 때 키-값 쌍을 접근하려면 어떻게 할까?

for i in x:
  print(i, end=' ') #a b c d 

이 경우에는 값은 출력되지 않고 키만 출력된다. 그렇다고

for k, v in zip(x.keys(), x.values()):
  print(k,v, end = " ") #a 10 b 20 c 30 d 40 

이렇게 하지 말자..

키와 값을 동시에 접근하려면 다음과 같이 item()을 사용하면 된다.

for 키, 값 in 딕셔너리.items():
     반복할 코드

for key, value in x.items():
  print(key, value) #a 10 b 20 c 30 d 40 

이렇게 접근하면 된다. 또는

for key, value in {'a': 10, 'b': 20, 'c': 30, 'd': 40}.items():
    print(key, value)

이렇게 직접 접근해도 상관없다.

a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
print(a.keys()) #dict_keys(['name', 'phone', 'birth'])
print(a.values()) #dict_values(['pey', '010-9999-1234', '1118'])

list(a.keys()) #['name', 'phone', 'birth']

a.items() #dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

for value in x.values():
  print(value, end = " ") #10 20 30 40 

for key in x.keys():
  print(key, end = " ") #a b c d 

그 외

a.get('name')

a.get('name')은 a['name']을 사용했을 때와 동일

a.get('address', 'location')

찾으려는 Key가 없을 경우 미리 정해 둔 디폴트 값을 대신 가져오게 하고 싶을 때에는 get(x, '디폴트 값')을 사용

'name' in a #True

in은 해당 Key가 딕셔너리 안에 있는지 조사

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
x.setdefault('e')
x #{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': None}

setdefault(키, 기본값)의 형태로 키와 기본값을 지정하면
값에 기본값을 저장한 뒤 해당 값을 반환

collections 모듈의 defaultdict 클래스와 유사하다.

update()

• 반환값은 None.
• 기존 키를 덮어쓴다.

수정,추가

• update(키=값)은 딕셔너리에서 키의 값을 수정
• 단, 이 때 키는 문자열일 때만 사용
• 키가 숫자일 경우에는 update(딕셔너리), update(리스트), update(튜플)로 값을 수정
• 키가 없으면 키-값 쌍을 추가

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
x.update(a = 100)
x #{'a': 100, 'b': 20, 'c': 30, 'd': 40}

딕셔너리가 x = {'a': 10}이라면 x.update(a=90)과 같이
키에서 작은따옴표 또는 큰따옴표를 빼고 키 이름과 값을 지정

x.update(e=50)
x #{'a': 100, 'b': 20, 'c': 30, 'd': 40, 'e': 50}

x.update({1: 'ONE', 3: 'THREE'})
x #{'a': 100, 'b': 20, 'c': 30, 'd': 40, 'e': 50, 1: 'ONE', 3: 'THREE'}

x.update([[2, 'TWO'], [4, 'FOUR']])

y.update(zip([1, 2], ['one', 'two']))
y #{1: 'one', 2: 'two'}

update(반복가능한객체)는 키-값 쌍으로 된 반복 가능한 객체로 값을 수정

결합

• 한 딕셔너리의 키/값들을 복사해서 다른 딕셔너리에 붙여 두 딕셔너리를 결합

a = { 'x' : 1 , 'y' : 2 }
b = { 'a' : 1,  'b' : 2 }
a.update(b)
print(a) #{'x': 1, 'y': 2, 'a': 1, 'b': 2}
print(b) #{'a': 1, 'b': 2}

이 떄 원본 a가 수정되었다.

print(a.update(b)) #None

update() 자체는 리턴이 None이다.

a = { 'x' : 1 , 'y' : 2 }
b = { 'x' : 111,  'b' : 2 }
a.update(b)
print(a) #{'x': 1, 'y': 2, 'a': 1, 'b': 2}

키가 중복되는 경우

dict.fromkeys(키리스트)

• dict.fromkey() 에 리스트나 튜플을 넣으면 딕셔너리를 생성
• 값은 모두 None으로 저장
• dict.fromkeys(키리스트, 값)처럼 키 리스트와 값을 지정하면 해당 값이 키의 값으로 저장

keys = ['a', 'b', 'c', 'd']
dict.fromkeys(keys) #{'a': None, 'b': None, 'c': None, 'd': None}

keys = ['a', 'b', 'c', 'd']
dict.fromkeys(keys, 100) #{'a': 100, 'b': 100, 'c': 100, 'd': 100}

딕셔너리 표현식

• 딕셔너리 안에 키와 값, for 반복문을 지정

keys = ['a', 'b', 'c', 'd']
x = {key: value for key, value in dict.fromkeys(keys).items()}
x #{'a': None, 'b': None, 'c': None, 'd': None}

{key: value for key, value in dict.fromkeys(keys).items()} #{'a': None, 'b': None, 'c': None, 'd': None}

{key: 0 for key in dict.fromkeys(['a', 'b', 'c', 'd']).keys()} # 키만 가져옴 {'a': 0, 'b': 0, 'c': 0, 'd': 0}

{value: 0 for value in {'a': 10, 'b': 20, 'c': 30, 'd': 40}.values()} # 값을 키로 사용 {10: 0, 20: 0, 30: 0, 40: 0}

딕셔너리에서 특정 값을 가진 키/값 쌍을 삭제할 때, 반복문으로 순회하면서 삭제하면 다음과 같이 에러가 발생한다.

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
 
for key, value in x.items():
    if value == 20:    # 값이 20이면
        del x[key]     # 키-값 쌍 삭제
 
print(x) #RuntimeError: dictionary changed size during iteration

이 경우 다음과 같이 사본을 만들어 순회하거나

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}

for key, value in x.copy().items():
    if value == 20:    # 값이 20이면
        del x[key]     # 키-값 쌍 삭제

print(x)  # {'a': 10, 'c': 30, 'd': 40}

딕셔너리 표현식을 사용하여
삭제할 키-값 쌍을 제외하고 남은 키-값 쌍으로 딕셔너리를 새로 만들면 된다.

x = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
x = {key: value for key, value in x.items() if value != 20}
print(x)  # {'a': 10, 'c': 30, 'd': 40}

REFERENCE
PYTHON DOCS
wikdocs
코딩도장