파이썬 사전을 만든 후에 키를 파이썬 사전에 추가 할 수 있습니까?

방법이없는 것 같습니다 .add().

d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

여러 키를 동시에 추가하려면 dict.update()다음을 사용하십시오 .

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

단일 키를 추가하는 경우 허용되는 답변의 계산 오버 헤드가 줄어 듭니다.

파이썬 사전에 대한 정보를 통합하고 싶습니다.

빈 사전 만들기

data = {}
# OR
data = dict()

초기 값으로 사전 만들기

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

단일 값 삽입 / 업데이트

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

여러 값 삽입 / 업데이트

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

원본을 수정하지 않고 병합 된 사전 만들기

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

사전에서 항목 삭제

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

키가 이미 사전에 있는지 확인

key in data

사전에서 쌍을 반복

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

두 목록에서 사전 만들기

data = dict(zip(list_with_keys, list_with_values))

Python 3.5를 처음 사용함

원본을 수정하지 않고 병합 된 사전 만들기 :

사전 언 패킹 이라는 새로운 기능을 사용합니다 .

data = {**data1, **data2, **data3}

Python 3.9의 새로운 기능

기존 사전에 대한 값 업데이트 또는 추가

업데이트 운영자는 |= 이제 사전 작동 :

data |= {'c':3,'d':4}

원본을 수정하지 않고 병합 된 사전 만들기

병합 연산자는 | 이제 사전 작동 :

data = data1 | {'c':3,'d':4}

더 추가하십시오!

"파이썬 사전을 만든 후에 키를 추가 할 수 있습니까? .add () 메소드가없는 것 같습니다."

예, 가능하며이를 구현하는 메소드가 있지만 직접 사용하고 싶지는 않습니다.

사용법과 사용하지 않는 방법을 보여주기 위해 dict 리터럴을 사용하여 빈 dict를 작성하십시오 {}.

my_dict = {}

모범 사례 1 : 첨자 표기법

하나의 새 키와 값으로이 dict를 업데이트하려면 항목 할당을 제공 하는 아래 첨자 표기법 (여기에서 매핑 참조) 을 사용 하십시오 .

my_dict['new key'] = 'new value'

my_dict 지금 :

{'new key': 'new value'}

모범 사례 2 : update방법-2 가지 방법

또한 이 update방법을 사용하여 여러 값으로 dict를 효율적으로 업데이트 할 수도 있습니다 . 우리는 불필요하게 dict여기에 여분의 것을 만들 수 있으므로 , 우리 dict는 이미 다른 목적으로 만들어 졌거나 사용 되기를 바랍니다 .

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict 지금 :

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

update 메소드를 사용 하여이 작업을 수행하는 또 다른 효율적인 방법은 키워드 인수를 사용하는 것입니다.하지만 합법적 인 파이썬 단어 여야하므로 공백이나 특수 기호를 사용하거나 숫자로 이름을 시작할 수 없지만 많은 사람들이이를 더 읽기 쉬운 방법으로 생각합니다 dict에 대한 키를 작성하려면 여기에 불필요한 추가 작성을 피하십시오 dict.

my_dict.update(foo='bar', foo2='baz')

그리고 my_dict지금 :

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

이제 우리는을 업데이트하는 세 가지 파이썬 방식을 다루었습니다 dict.

마술 방법 __setitem__과 피해야하는 이유

dict사용하지 말아야 할 방법을 업데이트하는 또 다른 방법이 있습니다 __setitem__. 다음은이 __setitem__방법을 사용하여 키-값 쌍을에 추가하는 방법 dict과이를 사용하는 성능이 좋지 않음을 보여주는 예입니다.

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

따라서 아래 첨자 표기법을 사용하는 것이 실제로 사용하는 것보다 훨씬 빠릅니다 __setitem__. 파이썬적인 일을하는 것, 즉 사용되는 방식으로 언어를 사용하는 것은 일반적으로 더 읽기 쉽고 계산적으로 효율적입니다.

dictionary[key] = value

사전 내에 사전을 추가하려면이 방법으로 사전을 추가 할 수 있습니다.

예 : 사전 및 하위 사전에 새 항목 추가

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

산출:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

참고 : 파이썬은 먼저 하위를 추가해야합니다

dictionary["dictionary_within_a_dictionary"] = {}

항목을 추가하기 전에.

정통 구문은 d[key] = value이지만 키보드에 대괄호 키가없는 경우 다음을 수행 할 수 있습니다.

d.__setitem__(key, value)

실제로, 정의 __getitem__와 __setitem__메소드는 클래스가 대괄호 구문을 지원하도록하는 방법입니다. https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php를 참조 하십시오

하나를 만들 수 있습니다.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

제공합니다 :

>>> 
{'apples': 6, 'bananas': 3}

이 인기있는 질문 은 사전을 병합하는 기능적 방법 a과 b.

다음은 좀 더 간단한 방법입니다 (Python 3에서 테스트).

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

참고 : 위의 첫 번째 방법은 키 b가 문자열 인 경우에만 작동합니다 .

단일 요소를 추가하거나 수정하기 위해 b사전에는 하나의 요소 만 포함됩니다.

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

이것은 ...에 해당합니다.

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )

불변의 세계에 살고 싶다고 가정하고 원본을 수정하고 싶지는 않지만 원본 dict에 새 키를 추가 한 결과로 새로운 것을 만들고자합니다 .

Python 3.5 이상에서는 다음을 수행 할 수 있습니다.

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

Python 2와 동등한 기능은 다음과 같습니다.

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

다음 중 하나 후에

params 여전히 같다 {'a': 1, 'b': 2}

과

new_params 동일하다 {'a': 1, 'b': 2, 'c': 3}

원본을 수정하지 않으려는 경우가 있습니다 (원본에 추가 한 결과 만 원함). 나는 이것을 다음과 같은 상쾌한 대안으로 생각한다.

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

또는

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

참조 : https://stackoverflow.com/a/2255892/514866

너무 많은 답변과 여전히 모든 사람들이 이상하게 명명되고, 이상하게 행동하지만 여전히 편리하다는 사실을 잊었습니다. dict.setdefault()

이

value = my_dict.setdefault(key, default)

기본적 으로이 작업을 수행합니다.

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

예 :

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored

두 개의 사전을 결합하지 않고 사전에 새 키-값 쌍을 추가하는 경우 아래 첨자 표기법을 사용하는 것이 가장 좋습니다.

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

그러나 예를 들어 수천 개의 새로운 키-값 쌍을 추가하려면이 update()방법을 사용하는 것이 좋습니다 .

나는 또한 파이썬의 지적 도움이 될 것이라고 생각 collections단순화 많은 유용한 사전 서브 클래스와 래퍼 구성 모듈 사전에 추가 및 데이터 유형의 수정 특별히를 defaultdict:

누락 된 값을 제공하기 위해 팩토리 함수를 호출하는 dict 서브 클래스

이것은 항상 동일한 데이터 유형 또는 구조로 구성된 사전 (예 : 목록 사전)으로 작업하는 경우에 특히 유용합니다.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

키가 아직 존재하지 않으면 defaultdict주어진 값 (이 경우에는 10)을 초기 값으로 지정합니다 (종종 루프 내부에서 사용됨). 이 :이 작업은 따라서 두 가지 일을 (질문에 따라) 사전에 새 키를 추가 하고 키가 아직 존재하지 않는 경우 값을 할당합니다. 표준 사전을 사용하면 +=작업이 아직 존재하지 않는 값에 액세스하려고 할 때 오류가 발생 합니다.

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

를 사용하지 않으면 defaultdict새로운 요소를 추가하는 코드의 양이 훨씬 커지고 다음과 같이 보일 것입니다.

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdict또한 복잡한 데이터 형식으로 사용될 수 list와 set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

요소를 추가하면 목록이 자동으로 초기화됩니다.

여기에 보이지 않는 다른 방법이 있습니다.

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

사전 생성자와 암시 적 확장을 사용하여 사전을 재구성 할 수 있습니다. 또한 흥미롭게도,이 방법은 사전 구성 ( Python 3.6 이후) 동안 위치 순서를 제어하는 ​​데 사용될 수 있습니다 . 실제로, 삽입 순서는 Python 3.7 이상에서 보장됩니다!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

위의 사전 이해를 사용하고 있습니다.

키가 이미 존재하는지 먼저 확인

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

새로운 키와 값을 추가 할 수 있습니다

사전 키, 값 클래스를 추가하십시오.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)