왜 dict [key] 대신 dict.get (key)입니까?

오늘 나는 dict방법을 발견했다get 사전에 주어진 키, 관련 값을 반환합니다.

이 기능은 어떤 목적으로 유용합니까? 사전에서 키와 관련된 값을 찾으려면 할 수 dict[key]있으며 동일한 것을 반환합니다.

dictionary = {"Name": "Harry", "Age": 17}
dictionary["Name"]
dictionary.get("Name")

키가없는 경우 기본값을 제공 할 수 있습니다.

dictionary.get("bogus", default_value)

반환 default_value(당신이 무엇을 선택하든), 반면

dictionary["bogus"]

을 올릴 것 KeyError입니다.

생략 된 경우 default_value이며 None, 그러한

dictionary.get("bogus")  # <-- No default specified -- defaults to None

None처럼 반환

dictionary.get("bogus", None)

할 것이다.

dict.get()방법 은 무엇입니까 ?

이미 언급했듯이이 get방법에는 결 측값을 나타내는 추가 매개 변수가 포함되어 있습니다. 설명서에서

get(key[, default])

키가 사전에 있으면 키의 값을 리턴하고 그렇지 않으면 기본값을 리턴하십시오. 기본값이 지정되지 않은 경우 기본값은 없음으로 설정되므로이 메소드는 절대로을 발생시키지 않습니다 KeyError.

예를 들어

>>> d = {1:2,2:3}
>>> d[1]
2
>>> d.get(1)
2
>>> d.get(3)
>>> repr(d.get(3))
'None'
>>> d.get(3,1)
1

어디서나 속도 개선이 있습니까?

로 언급 여기 ,

세 가지 방법 모두 단어 목록의 속성과 거의 독립적으로 비슷한 성능을 나타냅니다 (약 10 % 이내).

이전 get에는 속도가 상당히 느 렸지만 이제는 기본값을 반환하는 추가 이점과 함께 속도가 거의 비슷합니다. 그러나 모든 쿼리를 지우려면 상당히 큰 목록을 테스트 할 수 있습니다 (테스트에는 유효한 모든 키만 검색하는 것이 포함됩니다)

def getway(d):
    for i in range(100):
        s = d.get(i)

def lookup(d):
    for i in range(100):
        s = d[i]

이제이 두 기능을 사용하여 타이밍 timeit

>>> import timeit
>>> print(timeit.timeit("getway({i:i for i in range(100)})","from __main__ import getway"))
20.2124660015
>>> print(timeit.timeit("lookup({i:i for i in range(100)})","from __main__ import lookup"))
16.16223979

우리가 볼 수 있듯이 함수 조회가 없기 때문에 조회가 get보다 빠릅니다. 이것은 통해 볼 수 있습니다dis

>>> def lookup(d,val):
...     return d[val]
... 
>>> def getway(d,val):
...     return d.get(val)
... 
>>> dis.dis(getway)
  2           0 LOAD_FAST                0 (d)
              3 LOAD_ATTR                0 (get)
              6 LOAD_FAST                1 (val)
              9 CALL_FUNCTION            1
             12 RETURN_VALUE        
>>> dis.dis(lookup)
  2           0 LOAD_FAST                0 (d)
              3 LOAD_FAST                1 (val)
              6 BINARY_SUBSCR       
              7 RETURN_VALUE  

어디에서 유용할까요?

사전을 찾을 때마다 기본값을 제공 할 때마다 유용합니다. 이것은 감소

 if key in dic:
      val = dic[key]
 else:
      val = def_val

한 줄로 val = dic.get(key,def_val)

유용하지 않은 곳은 어디입니까?

KeyError특정 키를 사용할 수 없다는 내용 을 반환 할 때마다 기본값을 반환하면 특정 기본값이 핵심 일 수도 있습니다.

에 get같은 기능 을 가질 수 dict['key']있습니까?

예! __missing__dict 서브 클래스에서 를 구현해야합니다 .

샘플 프로그램은

class MyDict(dict):
    def __missing__(self, key):
        return None

작은 데모는

>>> my_d = MyDict({1:2,2:3})
>>> my_d[1]
2
>>> my_d[3]
>>> repr(my_d[3])
'None'

get두 번째 선택적 값을 사용합니다. 지정된 키가 사전에 없으면이 값이 반환됩니다.

dictionary = {"Name": "Harry", "Age": 17}
dictionary.get('Year', 'No available data')
>> 'No available data'

두 번째 매개 변수를 제공하지 않으면 None반환됩니다.

에서 dictionary['Year']와 같이 인덱싱을 사용하면 존재하지 않는 키가 발생 KeyError합니다.

파이썬을 사용하여 웹 데이터를 긁는 실제적인 예를 제공합니다. 값이없는 키를 얻는 많은 시간이 있습니다.이 경우 dictionary [ 'key']를 사용하면 dictionary.get ( 'key를 사용하면 오류가 발생합니다 ','return_otherwise ')에는 문제가 없습니다.

마찬가지로 목록에서 단일 값을 캡처하려고하면 list [0] 대신 ''.join (list)을 사용합니다.

도움이되기를 바랍니다.

[편집] 다음은 실용적인 예입니다.

예를 들어 API를 호출하면 구문 분석해야하는 JOSN 파일이 반환됩니다. 첫 번째 JSON은 다음과 같습니다.

{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","submitdate_ts":1318794805,"users_id":"2674360","project_id":"1250499"}}

두 번째 JOSN은 다음과 같습니다.

{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","users_id":"2674360","project_id":"1250499"}}

두 번째 JSON에는 "submitdate_ts"키가 없습니다. 이는 모든 데이터 구조에서 일반적입니다.

따라서 루프에서 해당 키의 값에 액세스하려고하면 다음과 같이 호출 할 수 있습니다.

for item in API_call:
    submitdate_ts = item["bids"]["submitdate_ts"]

키는 단순히 존재하지 않기 때문에 두 번째 JSON 행에 대한 역 추적 오류가 발생합니다.

이를 코딩하는 적절한 방법은 다음과 같습니다.

for item in API_call:
    submitdate_ts = item.get("bids", {'x': None}).get("submitdate_ts")

{ 'x': None}은 두 번째 수준에서 오류가 발생하지 않도록하기위한 것입니다. 물론 스크래핑을 수행하는 경우 코드에 내결함성을 더 높일 수 있습니다. 먼저 if 조건을 지정하는 것처럼

키를 찾을 수없는 경우 기본값을 지정할 수 있으므로 매우 유용합니다.

dictionary.get("Name",'harry')

이 기능은 어떤 목적으로 유용합니까?

하나의 특정 사용법은 사전으로 계산됩니다. 주어진 목록에서 각 요소의 발생 횟수를 계산한다고 가정 해 봅시다. 일반적인 방법은 키가 요소이고 값이 발생 횟수 인 사전을 만드는 것입니다.

fruits = ['apple', 'banana', 'peach', 'apple', 'pear']
d = {}
for fruit in fruits:
    if fruit not in d:
        d[fruit] = 0
    d[fruit] += 1

이 .get()방법을 사용하면 이 코드를보다 간결하고 명확하게 만들 수 있습니다.

for fruit in fruits:
    d[fruit] = d.get(fruit, 0) + 1

사용할 때 알아야 할 .get()사항 :

사전에 호출에 사용 된 키가 포함되어 .get()있고 그 값이 None인 경우, 기본값이 제공 되더라도 .get()메소드가 리턴 None합니다.

예를 들어, 다음은 예상 None과 달리 'alt_value'를 반환합니다 .

d = {'key': None}
d.get('key', 'alt_value')

.get()두 번째 값은 제공된 키가 사전에없는 경우에만 해당 호출의 리턴 값이 아닌 경우에만 리턴됩니다 None.

왜 dict [key] 대신 dict.get (key)입니까?

0. 요약

에 비교 dict[key], dict.get키에 대한 찾고 대체 값을 제공합니다.

1. 정의

get (key [, default]) 4. 내장 타입 — 파이썬 3.6.4rc1 문서

키가 사전에 있으면 키의 값을 리턴하고 그렇지 않으면 기본값을 리턴하십시오. 기본값이 지정되지 않은 경우 기본값은 없음으로 설정되므로이 메소드는 KeyError를 발생시키지 않습니다.

d = {"Name": "Harry", "Age": 17}
In [4]: d['gender']
KeyError: 'gender'
In [5]: d.get('gender', 'Not specified, please add it')
Out[5]: 'Not specified, please add it'

2. 문제가 해결됩니다.

없는 경우 default value이러한 예외를 처리하기 위해 번거로운 코드를 작성해야합니다.

def get_harry_info(key):
    try:
        return "{}".format(d[key])
    except KeyError:
        return 'Not specified, please add it'
In [9]: get_harry_info('Name')
Out[9]: 'Harry'
In [10]: get_harry_info('Gender')
Out[10]: 'Not specified, please add it'

편리한 솔루션으로, dict.get불필요한 코드를 피하는 선택적 기본값을 도입했습니다.

3. 결론

dict.get 키가 사전에없는 경우 예외를 처리하기위한 추가 기본값 옵션이 있습니다.

이점이 될 수있는 한 가지 차이점은 존재하지 않는 키를 찾는 경우 대괄호 표기법을 사용할 때와는 달리 None을 얻습니다.이 경우 오류가 발생합니다.

print(dictionary.get("address")) # None
print(dictionary["address"]) # throws KeyError: 'address'

get 메소드에 대해 마지막으로 유용한 것은 기본값에 대한 추가 선택적 인수를 수신한다는 것입니다. 즉, 학생의 점수 값을 얻으려고 시도했지만 학생이 얻을 수있는 점수 키가 없습니다. 대신 0.

따라서 이것을하는 대신 (또는 비슷한 것) :

score = None
try:
    score = dictionary["score"]
except KeyError:
    score = 0

우리는 할 수있어:

score = dictionary.get("score", 0)
# score = 0

사용법에 따라이 get방법을 사용해야합니다 .

예 1

In [14]: user_dict = {'type': False}

In [15]: user_dict.get('type', '')

Out[15]: False

In [16]: user_dict.get('type') or ''

Out[16]: ''

예 2

In [17]: user_dict = {'type': "lead"}

In [18]: user_dict.get('type') or ''

Out[18]: 'lead'

In [19]: user_dict.get('type', '')

Out[19]: 'lead'