#20-파이썬 기초 실습 - 딕셔너리 Dictonary-1

파이썬 기초 실습 - 딕셔너리 Dictionary - 1¶

데이타 타입¶

* 딕셔너리(Dictionary)

In [1]:

dict_d = {'key1':'item1','key2':'item2'}

In [2]:

dict_d

Out[2]:

{'key1': 'item1', 'key2': 'item2'}

In [3]:

dict_d['key2']

Out[3]:

'item2'

In [4]:

type(dict_d)

Out[4]:

dict

In [5]:

id(dict_d)

Out[5]:

2308704175432

1. 딕셔너리 객체 호출¶

• 딕셔너리는 시퀀스 자료형이다.

In [6]:

dict_d = {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
for key in dict_d:
    print(key, dict_d)

F {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
A {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
B {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
C {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
D {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
E {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}

2. 딕셔너리의 키에 대한 반복 추출¶

In [7]:

dict_d = {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
for key in dict_d:
    print(key, dict_d[key])

F 3
A 1
B 2
C 3
D 4
E 8

In [8]:

# 딕셔너리의 모든 키값의 순차적 추출
# F A B C D E 순서가 아닌 A B C D E F 순으로 
# collections의 OrderedDict을 이용해서 키 순서대로 정렬하였다. 여기서 키의 크기순으로 정렬되는 것이다.
from collections import OrderedDict
dict_d = {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
ordered_dict = OrderedDict(sorted(dict_d.items()))
for key in ordered_dict.items():
    print(key)

('A', 1)
('B', 2)
('C', 3)
('D', 4)
('E', 8)
('F', 3)

In [9]:

# 딕셔너리의 키와 값을 동시에 참조하여 추출
dict_d = {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
for key in dict_d.items():
    print(key, dict_d)

('F', 3) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
('A', 1) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
('B', 2) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
('C', 3) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
('D', 4) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}
('E', 8) {'F': 3, 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 8}

사전형(dictionary type) 자료구조¶

딕셔너리의 형식 ( 딕셔너리의 표현 )¶

In [10]:

dict_d = {'id': 'microfun', 'name': 'song'}
dict_d['name']  # 키로 값을 불러온다. 

Out[10]:

'song'

In [11]:

type(dict_d)

Out[11]:

dict

In [12]:

dict_d = {1: 12, 2: 13, 3: 11,4: 10,5: 0,6: 9,7: 8}

In [13]:

dict_d[2]

Out[13]:

13

In [14]:

dict_d[1]

Out[14]:

12

In [15]:

dict_d[7]

Out[15]:

8

In [16]:

dict_d = {id : 485}  # 내장 함수를 키로 넣으면 오류는 안 난다. 
dict_d

Out[16]:

{<function id(obj, /)>: 485}

In [17]:

dict_d  # {<function id(obj, /)>: 485} id는 내장함수라서 이런 결과가 나왔다. 
        # 키에 람다식을 넣을수도 있다.

Out[17]:

{<function id(obj, /)>: 485}

In [18]:

# 숫자를 키로 만들수 있다.
# 데이터에 리스트 값도 넣을수 있다. (다른 데이터구조도 가능)
dict_d = {1 : [1,2,3]}  

In [19]:

dict_d

Out[19]:

{1: [1, 2, 3]}

1. dict(). 내장 함수의 이용.¶

In [20]:

# dict() 내장함수는 String으로 지정하지 않더라도 자동으로 키에 String으로 들어간다. {'value': 1}
dict(value = 1)  

Out[20]:

{'value': 1}

In [21]:

# 키에 String으로 넣으니 에러 발생. SyntaxError: keyword can't be an expression
dict('value'=1)  

  File "<ipython-input-21-f603ef2710b7>", line 2
    dict('value'=1)
        ^
SyntaxError: keyword can't be an expression

In [22]:

# 키에 int를 넣으니 에러 발생. SyntaxError: keyword can't be an expression
dict(1=value) 

  File "<ipython-input-22-4652b2127dc7>", line 2
    dict(1=value)
        ^
SyntaxError: keyword can't be an expression

In [23]:

dict_d = dict(one=1, two=2)  #  두 개의 데이터를 한 번에 넣을 수 있다.
print(dict_d)
type(dict_d)

{'one': 1, 'two': 2}

Out[23]:

dict

In [24]:

dict_d = dict([(1,'one' ),('two',2)])  #  리스트에 튜플 형식으로 쌍을 묶으면 사전타입으로 바꿀 수 있다.
print(dict_d)
type(dict_d)

{1: 'one', 'two': 2}

Out[24]:

dict

In [25]:

dict_d = dict({1:'one', 'two':2})  #  원래 사전 타입을 넣어도 된다.
print(dict_d)
type(dict_d)

{1: 'one', 'two': 2}

Out[25]:

dict

2. zip(). 내장 함수의 이용.¶

In [26]:

dict_d = ['one', 'two', 'three']
dict_e = (1, 2, 3)
dict(zip(dict_d, dict_e))  # 패킹과 같은 효과이다.

Out[26]:

{'one': 1, 'two': 2, 'three': 3}

In [27]:

dict(zip(dict_e, dict_d))  # 반대의 경우에는 숫자를 키로 넣을 수 있다.

Out[27]:

{1: 'one', 2: 'two', 3: 'three'}

In [28]:

x = dict(zip(dict_d, dict_e))
y = dict(zip(dict_e, dict_d))
dict_d[0] = 'jeon'  # 값을 바꿨다.

In [29]:

dict_d  #. 출력값 확인.

Out[29]:

['jeon', 'two', 'three']

In [30]:

dict_e  # 변화가 없다. 주소가 아닌 값만 복사된 것을 알 수 있다.

Out[30]:

(1, 2, 3)

In [31]:

x  # 변화가 없다. 주소가 아닌 값만 복사된 것을 알 수 있다.

Out[31]:

{'one': 1, 'two': 2, 'three': 3}

In [32]:

y

Out[32]:

{1: 'one', 2: 'two', 3: 'three'}

3. 딕셔너리의 연산¶

In [33]:

dict_d = {'2': '2번', '3': '3번'}
dict_d['1'] = '1번'  # a에 키는 '1', 값은 '3번'이라는 요소를 추가했다.
dict_d

Out[33]:

{'2': '2번', '3': '3번', '1': '1번'}

In [34]:

dict_d['1'] = '1번'  # 키가 1인 데이터의 값을 '1번'으로 바꿨다.
dict_d

Out[34]:

{'2': '2번', '3': '3번', '1': '1번'}

In [35]:

len(dict_d)  # 데이터 갯수를 세어주는 length()함수.

Out[35]:

3

4. 딕셔너리의 키 멤버십 테스트¶

In [36]:

dict_d = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
'one' in dict_d

Out[36]:

True

In [37]:

'one' in dict_d 

Out[37]:

True

In [38]:

1 in dict_d.values()  

Out[38]:

True

In [39]:

100 in dict_d.values()

Out[39]:

False

4. 딕셔너리의 포맷팅¶

In [40]:

dict_d = '%(name)s, %(age)s'  # 포맷팅 뿐만 아니라 어느 데이터가 들어가야 하는지도 알려준다.
print(dict_d)

dict_e = '%(name)s, %(money)s'  # 비교를 위해 뒤에 요소를 바꿨다.
print(dict_e)

%(name)s, %(age)s
%(name)s, %(money)s

In [41]:

dict_d % {'name':'seong', 'age':'38'}

Out[41]:

'seong, 38'

In [42]:

dict_e % {'name':'seong', 'money':'1억'}

Out[42]:

'seong, 1억'

In [ ]: