본문 바로가기
SK 행복성장캠퍼스/Python 기초

0902_3일차_딕셔너리

by NickNuma 2020. 9. 6.

이번엔 집합형 자료형의 마지막 딕셔너리입니다.


딕셔너리는 일단, 집합형 자료형입니다.
{key : value, key : value}, dict([list [key, value], [key, value]]), dict(key = value, key = value)로 생성 가능하고
{ } <- 이렇게 빈 딕셔너리를 생성할 수도 있습니다. (* {}는 set 값이 아니라 빈 딕셔너리 값으로 저장됩니다.)
딕셔너리는 key와 value, 쌍으로 관리됩니다. key를 이용해서 value를 호출할 수 있습니다.
셋 데이터형과 마찬가지로 순서가 없고 중복도 불가합니다.
key 값은 변경이 불가합니다. 하지만 value 값은 수정 가능합니다. key = immutable, value = mutable

"""
    집합형 자료형
    1) 문자열
    2) 리스트
    3) 튜플
    4) 셋
    4) 딕셔너리
        a. 문자열 생성 방법
            (1) {key : value} 형태
            (2) dict(리스트의 리스트)
            (3) dict(key = value, key = value) (*****)
            (4) {}      # 빈 딕셔너리

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

        ## c. 인덱싱 및 슬라이싱   ==> 순서가 없기때문에 불가
        c. 문자열 특징
            - {key : value, key : value} 형태의 key / value 쌍으로 데이터 관리
            - 저장되는 데이터의 순서가 없다.
            - key를 이용해서 value를 호출.
            - key값은 immutable 데이터 ( 정수, 문자열, 튜플 )
              value는 mutable (수정 가능한) 데이터

"""

 


#1. 딕셔너리 생성
m = {}  # 빈 딕셔너리
m2 = {"key" : "value", "name" : "홍길동", "age" : 20}  # ****** 자주 쓰임
m3 = dict([["key", "value"], ["name", "홍길동"], ["age", 20]])
m4 = dict(key = "value", name = "홍길동", age = 20)      # ****** 자주 쓰임
print(m, type(m))       # {} <class 'dict'>
print(m2, type(m2))     # {'key': 'value', 'name': 'avd', 'age': 30} <class 'dict'>
print(m3, type(m3))     # {'key': 'value', 'name': '홍길동', 'age': 20} <class 'dict'>
print(m4, type(m4))     # {'key': 'value', 'name': '홍길동', 'age': 20} <class 'dict'>


딕셔너리에서 사용가능한 함수를 다뤄보겠습니다.

"""
**딕셔너리에서 사용가능한 함수

# 딕셔너리 외부 패키지의 함수
['__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__', 

# 딕셔너리 클래스 내부의 함수
'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 
'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

"""

 


1. 요소 추가 ==> 변수명[key]  = "value"     (* 동일 키 값이 없으면 요소 추가 / 있으면 요소 변경)

# (1)요소 추가 => 변수명[key] = "value"
m = {"name":"홍길동", "age":20}

m["address"] = "서울"
m["email"]  = "hong@gmail.com"
print("1. 요소 추가:", m)  

"""
1. 요소 추가: {'name': '홍길동', 'age': 20, 'address': '서울', 'email': 'hong@gmail.com'}
"""

2. 요소 변경 ==> 변수명[key] = "value"      (* 동일 키 값이 없으면 요소 추가 / 있으면 요소 변경)

# (2) 요소 변경 => 변수명[key] = "value"
m = {'name': '홍길동', 'age': 20, 'address': '서울', 'email': 'hong@gmail.com'}

m["address"] = "제주"          # 키값이 없으면 추가, 키값이 존재하면 수정
print("2. 요소 변경:", m)

"""
2. 요소 변경: {'name': '홍길동', 'age': 20, 'address': '제주', 'email': 'hong@gmail.com'}
"""

3. 요소 삭제 ==> 변수명.pop(살제할 key)

# (3) 요소 삭제  => 변수명.pop(삭제할 키 값)
a = {'name': '홍길동', 'age': 20, 'address': '제주', 'email': 'hong@gmail.com'}

a.pop('email')      # 변수명.pop(key)
print("3. 요소 삭제(pop):", a)

"""
3. 요소 삭제(pop): {'name': '홍길동', 'age': 20, 'address': '제주'}
"""

4. 요소 삭제 ==> del 변수명[삭제할 key]

# (4) 요소 삭제  => del 변수명[삭제할 키 값]
a = {'name': '홍길동', 'age': 20, 'address': '제주', 'email': 'hong@gmail.com'}

del a['address']    # del 변수명[key]
print("4. 요소 삭제(del):", a)

"""
4. 요소 삭제(del): {'name': '홍길동', 'age': 20, 'email': 'hong@gmail.com'}
"""

5. 요소 전체 삭제 ==> 변수명.clear()

# (5) 요소 전체 삭제  => 변수명.clear()
a = {'name': '홍길동', 'age': 20, 'address': '제주', 'email': 'hong@gmail.com'}

a.clear()
print("5. 요소 전체 삭제(clear):", a)

"""
5. 요소 전체 삭제(clear): {}
"""

6. 요소 병합 ==> 변수명.update(변수명)

# (6) 요소 병합     => 변수명.update(변수명)
a = {'name': '홍길동', 'age': 20}
b = {'address': '제주', 'email': 'hong@gmail.com'}

a.update(b)
print("6. 요소 병합:", a)

"""
6. 요소 병합: {'name': '홍길동', 'age': 20, 'address': '제주', 'email': 'hong@gmail.com'}
"""

7. 중복 요소 병합 ==> 중복값 덮어씌워질 변수 A.update(중복값 덮어씌울 변수 B) 
(A에 B와 같은 중복값이 있다면 B에 있는 value값으로 병합)

# (7) 중복 요소 병합  ==> 병합을 이용하면 여러 요소를 한번에 수정 가능
a = {'name': '홍길동', 'age': 20, 'address' : '서울'}
b = {'age': 30, 'address': '제주', 'email': 'hong@gmail.com'} # 나중에 중복된 값으로 병합
a.update(b)
print("7. 중복 요소 병합:", a)

"""
7. 중복 요소 병합: {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}
"""

8. 중복 요소 병합 ==> 변수 A.update(중복값 수정을 위한 dict B)
(7과 같은 말, 뒤의 변수 value로 앞의 변수 값 overwrite)

# (8) 병합을 활용한 멀티 수정 (한 번에 이름과 나이 변경)
a = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

a.update({'name':'이순신', 'age':45})
print("8. 중복 요소 병합을 활용한 여러 요소 수정:", a)

"""
8. 중복 요소 병합을 활용한 여러 요소 수정: {'name': '이순신', 'age': 45, 'address': '제주', 'email': 'hong@gmail.com'}
"""

9. Key 값을 이용해 value 값 얻어오기 ==> 변수명[key]
(존재하지 않는 key를 사용하면 Error가 발생합니다.)

# (9) Key 값을 활용한 value 값 얻기
x = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}
print("9. name 얻기:", x['name'])
# print("9. name 얻기:", x['phone'])    # 존재하지 않는 key 사용 => Error

"""
9. name 얻기: 홍길동
"""

10.  value 값 얻어오기 ==> 변수명.get(Key)
get(key)로 value값을 얻어오려할 때,
가) 존재하지 않는 Key의 경우 None의 값을 반환.
나) 존재하지 않는 Keyvalue 값과 함께 물으면 해당 key 값과 value 값을 반환한다. (해당 dict 정보에는 영향 x)
다) 존재하는 Key에 내가 원하는 Value값을 넣고 물으면 존재하는 해당 Key와 해당 키에 연계된 dict의 value를 반환한다.
     ===> get()함수dict 자료에 변경을 줄 수 없다.

# (10) get()을 활용한 value 값 얻기
x = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

print("10. name 얻기:", x.get("name"))
# 10. name 얻기: 홍길동

print("10. name 얻기:", x.get("phone"))   # 존재하지 않는 key 사용 => None값 도출
# 10. name 얻기: None

print("10. name 얻기:", x.get("phone", "010-1234-5678")) # get으로 물을 때, 데이터값을 함께 넣어 None값일 때 데이터값을 출력 시킬 수 있다.
# 10. name 얻기: 010-1234-5678

print("10. name 얻기:", x.get("name", "이순신")) # 딕셔너리에 해당 key와 value가 존재하면 내가 지정한 value값이 아닌 딕셔너리 내 해당 key의 value가 출력.
# 10. name 얻기: 홍길동

print("10. name 얻기:", x) # 이 때에 dict 안 데이터의 변경은 없다.
# 10. name 얻기: {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

11. Key 값 얻기 ==> 변수명.keys()

#11.  keys()
x = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

print("11. key값만 얻기:", x.keys())
# 11. key값만 얻기: dict_keys(['name', 'age', 'address', 'email'])

print("11. key값만 얻기(list):", list(x.keys()))                # 값을 사용할 수 있게끔 list로 만들어 줌.
# 11. key값만 얻기(list): ['name', 'age', 'address', 'email']

12. Value 값 얻기 ==> 변수명.values()

#11. values()
x = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

print("11. value값만 얻기:", x.values())
# 11. value값만 얻기: dict_values(['홍길동', 30, '제주', 'hong@gmail.com'])

print("11. value값만 얻기(list):", list(x.values()))            # 값을 사용할 수 있게끔 list로 만들어 줌.
# 11. value값만 얻기(list): ['홍길동', 30, '제주', 'hong@gmail.com']

13. Key와 Value 쌍 모두 얻기 ==> 변수명.items()

#11. items()
x = {'name': '홍길동', 'age': 30, 'address': '제주', 'email': 'hong@gmail.com'}

print("11. (key, value) 쌍 값 얻기:", x.items())
# 11. (key, value) 쌍 값 얻기: dict_items([('name', '홍길동'), ('age', 30), ('address', '제주'), ('email', 'hong@gmail.com')])

print("11. (key, value) 쌍 값 얻기(list):", list(x.items()))    # 값을 사용할 수 있게끔 list로 만들어 줌.
# 11. (key, value) 쌍 값 얻기(list): [('name', '홍길동'), ('age', 30), ('address', '제주'), ('email', 'hong@gmail.com')]

14. 서로 다른 리스트/튜플의 값을 묶어주는 함수 ==> zip(리스트 / 튜플)
이후 zip으로 묶인 것을 dict()을 사용Key:Value값을 갖는 딕셔너리로 만들 수 있다.
(이후 묶어서 리스트, 튜플형으로도 만들 수 있지만... 그럴 이유는 없는 듯?)

# __builtins__의 zip 함수 ==> 서로 다른 리스트의 값을 묶어주는 역할    ==> 이후 dict 변환 가능
countries =["대한민국", "미국", "일본", "중국"]   # 튜플로도 묶어줄 수 있다.
population = [5000, 90000, 12000, 150000]

print("zip으로 묶고 dict으로 변경", zip(countries, population))         #zip(Key, Value)

"""
zip으로 묶고 dict으로 변경 <zip object at 0x000001D7108D2E00>
"""

b = dict(zip(countries, population))
print("zip으로 묶고 dict으로 변경", b, type(b))   #dict(zip(Key, Value))

"""
zip으로 묶고 dict으로 변경 {'대한민국': 5000, '미국': 90000, '일본': 12000, '중국': 150000}
"""

#필요하다면 zip을 이용해 튜플형으로 묶인 리스트를 만들 수는 있다. (필요할지는 모르겠네?)
a = list(zip(countries, population))
print("zip으로 묶고 list로 변경", a, type(a))   #dict(zip(Key, Value))

"""
zip으로 묶고 list로 변경 [('대한민국', 5000), ('미국', 90000), ('일본', 12000), ('중국', 150000)] <class 'list'>
"""

이로써 문자열, 리스트, 튜플, 셋, 딕셔너리. 집합형 데이터 포스팅을 마치고
다음엔 조건문을 들고 오겠습니다.

그럼 이만~

반응형

'SK 행복성장캠퍼스 > Python 기초' 카테고리의 다른 글

0902_3일차_반복문_for문  (0) 2020.09.06
0902_3일차_조건문  (0) 2020.09.06
0902_3일차_셋  (0) 2020.09.05
Python_변할 수 있는 데이터_없는 데이터_mutable/immutable  (0) 2020.09.05
0902_3일차_튜플  (0) 2020.09.05

댓글