Python Language
사전

통사론

• mydict = {}
• mydict [k] = 값
• 값 = mydict [k]
• 값 = mydict.get (k)
• value = mydict.get (k, "default_value")

매개 변수

비고

사전 값 액세스

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

위의 코드는 1234 를 인쇄합니다.

이 예제에서 "Hello" 라는 문자열을 키 라고 부릅니다. 키를 대괄호로 묶어 dict 의 값을 조회하는 데 사용됩니다.

숫자 1234 는 dict 정의에서 각 콜론 뒤에 표시됩니다. 이것을 "Hello" 가이 dict 매핑 하는 값 이라고합니다.

존재하지 않는 키로 이와 같은 값을 검색하면 KeyError 예외가 발생하고 catch되지 않으면 실행이 중지됩니다. KeyError 를 위험에 빠뜨리지 않고 값에 액세스하려면 dictionary.get 메소드를 사용할 수 있습니다. 기본적으로 키가 존재하지 않으면 메서드는 None 을 반환합니다. 조회가 실패한 경우 None 대신 반환하는 두 번째 값을 전달할 수 있습니다.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

이 예제에서 w 는 값 None 을 얻을 것이고 x 는 값 "nuh-uh" 얻을 것입니다.

dict () 생성자

dict() 생성자는 키워드 인수 또는 키 - 값 쌍의 단일 반복 가능 집합 또는 단일 사전 및 키워드 인수에서 사전을 만드는 데 사용할 수 있습니다.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

KeyError 예외 방지

사전을 사용할 때 존재하지 않는 하나의 함정은 존재하지 않는 키에 액세스하는 것입니다. 이것은 일반적으로 KeyError 예외를 발생 KeyError

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

키 오류를 방지하는 한 가지 방법은 부재 키의 경우에 반환 할 기본값을 지정할 수있는 dict.get 메서드를 사용하는 dict.get 입니다.

value = mydict.get(key, default_value)

mydict[key] 있으면 반환하고, 그렇지 않으면 default_value 반환합니다. 이것은 mydict 에 key 를 추가하지 않음에 mydict . 해당 키 값 쌍을 유지하려는 경우, 당신은 사용해야합니다 mydict.setdefault(key, default_value) 키 값 쌍을 저장 않습니다.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

문제를 해결할 수있는 또 다른 방법은 예외를 잡는 것입니다.

try:
    value = mydict[key]
except KeyError:
    value = default_value

키가 사전 in 있는지 확인할 수도 있습니다.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

그러나 멀티 스레드 환경에서는 검사 후에도 예외가 발생할 수있는 경쟁 조건을 생성하여 키를 사전에서 제거 할 수 있습니다.

또 다른 옵션은 dict의 하위 클래스 인 collections.defaultdict를 사용하는 것입니다.이 클래스는 new_key가 주어질 때 dict에 새로운 항목을 생성하기 위해 default_factory를가집니다.

키와 값에 액세스하기

사전을 사용하여 작업 할 때는 for 루프, 목록 이해 또는 일반 목록과 같이 사전의 모든 키와 값에 액세스해야하는 경우가 있습니다.

다음과 같은 사전을 생각해보십시오 :

mydict = {
    'a': '1',
    'b': '2'
}

keys() 메서드를 사용하여 keys() 목록을 가져올 수 있습니다.

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

대신 값 목록을 원하면 values() 메서드를 사용하십시오.

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

키와 해당 값을 모두 사용하려면 items() 메서드를 사용할 수 있습니다.

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

참고 : dict 은 정렬되지 않기 때문에 keys() , values() 및 items() 에는 정렬 순서가 없습니다. 이러한 메서드가 반환하는 순서에 신경 OrderedDict sort() , sorted() 또는 OrderedDict 사용하십시오.

Python 2/3의 차이점 : Python 3에서는 이러한 메서드가 목록이 아닌 특별한 반복 가능한 객체를 반환하며 Python 2 iterkeys() , itervalues() 및 itervalues() iteritems() 메서드와 동일합니다. 이 객체들은 대부분 차이점이 있지만 대부분 목록처럼 사용할 수 있습니다. 자세한 내용은 PEP 3106 을 참조하십시오.

사전 소개

사전은 Python에서 매핑 이라고도하는 키 값 저장소 의 한 예입니다. 키를 참조하여 요소를 저장하고 검색 할 수 있습니다. 사전은 키로 참조되므로 매우 빠른 조회가 있습니다. 키를 기준으로 항목을 참조 할 때 주로 사용되므로 정렬되지 않습니다.

딕트 작성

사전은 여러 가지 방법으로 시작할 수 있습니다.

리터럴 구문

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

사전 이해

d = {k:v for k,v in [('key', 'value',)]}

또한보십시오 : Comprehensions

내장 클래스 : dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

dict 수정하기

사전에 항목을 추가하려면 값이있는 새 키를 만들기 만하면됩니다.

d['newkey'] = 42

또한 list 과 dictionary 을 값으로 추가 할 수 있습니다.

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

항목을 삭제하려면 사전에서 키를 삭제하십시오.

del d['newkey']

기본 값이있는 사전

defaultdict 로 표준 라이브러리에서 사용 가능

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] using dict.setdefault() 를 사용하면 내장 된 dict 클래스 using dict.setdefault() 하는 경우 전에 존재하지 않은 키에 액세스 할 때마다 기본값을 만들 수 있습니다.

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

추가 할 값이 많은 경우 dict.setdefault() 는 호출 될 때마다 초기 값 (이 예제에서는 [] )의 새 인스턴스를 생성하여 불필요한 작업 부하를 생성 할 수 있음을 명심하십시오.

[*] Python Cookbook, David Beazley와 Brian K. Jones (O'Reilly)의 3 판. Copyright 2013 David Beazley and Brian Jones, 978-1-449-34037-7.

순서가 지정된 사전 만들기

사전의 키를 반복 할 때 결정된 순서를 따르는 정렬 된 사전을 만들 수 있습니다.

collections 모듈에서 OrderedDict 를 사용하십시오. 반복 될 때 항상 원래 게재 신청서의 사전 요소를 반환합니다.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

** 연산자를 사용하여 사전 압축 풀기

** 키워드 인수 unpacking 연산자를 사용하여 사전의 키 - 값 쌍을 함수의 인수로 전달할 수 있습니다. 공식 문서 의 간략한 예 :

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Python 3.5에서이 구문을 사용하여 임의의 수의 dict 객체를 병합 할 수도 있습니다.

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

이 예제에서 알 수 있듯이 중복 키는 마지막 값으로 매핑됩니다 (예 : "Clifford"가 "Nemo"보다 우선 함).

사전 병합

다음 사전을 고려하십시오.

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5 이상

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

이 예제에서 알 수 있듯이 중복 키는 마지막 값으로 매핑됩니다 (예 : "Clifford"가 "Nemo"보다 우선 함).

Python 3.3 이상

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

이 기술을 사용하면 마지막 값 ( "Clifford"가 "Nemo"에 찬성하여 버려집니다)보다 foremost 값이 주어진 키에 우선합니다.

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

이것은 병합을위한 ** 기반 기법 ( "Clifford"가 "Nemo"를 오버라이드 함)과 마찬가지로 후자의 값을 사용합니다.

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update 는 후자의 dict를 사용하여 이전의 dict를 겹쳐 씁니다.

후행 쉼표

목록 및 튜플과 마찬가지로 사전에 후행 쉼표를 포함 할 수 있습니다.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8은 후미 쉼표와 닫는 중괄호 사이에 공백을 두어야한다고 지시합니다.

사전 값의 모든 조합

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

위에 표시된 것과 같은 사전이 주어지면 해당 키를 탐색 할 일련의 값을 나타내는 목록이 있습니다. "x"="a" "y"=10 , "x"="a" "y"=10 등 모든 가능한 조합을 탐색 할 때까지 계속 탐색한다고 가정 해보십시오.

다음 코드를 사용하여 이러한 모든 값 조합을 반환하는 목록을 만들 수 있습니다.

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

그러면 변수 combinations 에 다음 목록이 저장됩니다.

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

사전 반복

사전을 반복자로 사용하면 (예 : for 문에서) 사전의 키 를 탐색합니다. 예 :

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

이해에 사용될 때도 마찬가지입니다.

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

사전 만들기

사전 작성 규칙 :

• 모든 키는 고유 해야합니다 (그렇지 않으면 오버라이드됩니다)
• 모든 키 해쉬해야합니다 (사용할 수있는 hash 를 해시 기능을, 그렇지 않으면 TypeError 발생합니다)
• 열쇠에 대한 특별한 순서는 없습니다.

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

사전 예제

사전은 키를 값에 매핑합니다.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

사전 값은 키로 액세스 할 수 있습니다.

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

사전은 JSON 스타일로 만들 수도 있습니다.

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

사전 값은 다음을 통해 반복 될 수 있습니다.

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette