사전에 새 키를 추가하려면 어떻게 해야 합니까?

사전에 새 키를 추가하려면 어떻게 해야 합니까?

기존 사전에 키를 추가하려면 어떻게 해야 합니까?.add()★★★★★★ 。

사전에서 해당 키에 값을 할당하여 새 키/값 쌍을 만듭니다.

d = {'key': 'value'}
print(d)  # {'key': 'value'}

d['mynewkey'] = 'mynewvalue'

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

키가 존재하지 않으면 키가 추가되어 해당 값을 가리킵니다.이 값이 존재하는 경우 이 값이 가리키는 현재 값을 덮어씁니다.

여러 키를 동시에 추가하려면 다음 명령을 사용합니다.

>>> 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}

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

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

빈 사전 만들기

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'

Python 3.9+:

업데이트 연산자 |=이제 사전에서 사용할 수 있습니다.

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

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

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

Python 3.5+:

이것은 사전 언팩이라고 불리는 새로운 기능을 사용합니다.

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

Python 3.9+:

병합 연산자 |이제 사전에서 사용할 수 있습니다.

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

사전에서 항목 삭제

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 사전이 생성된 후에 키를 추가할 수 있습니까?.add() 메서드는 없는 것 같습니다."

네, 가능합니다.실행 방법은 있습니다만, 직접 사용하고 싶지는 않습니다.

하기 위해 리터럴인 dict 리터럴, dict 리터럴로 빈를 만들어 {}:

my_dict = {}

베스트 프랙티스 1: 첨자 표기법

단일 새 키 및 값으로 이 딕트를 업데이트하려면 항목 할당에 대해 제공하는 첨자 표기법(여기의 매핑 참조)을 사용합니다.

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

my_dict★★★★

{'new key': 'new value'}

「」의 2:update-2 - 2 ways

또한 이 방법을 사용하여 여러 값을 사용하여 효율적으로 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'}

하는 또 키워드 인수를 만, 그것들은 워드여야 숫자로 할 수도 없습니다.의 키를 읽기 쉬운 이 생각하고 한 python 인수를 작성하는 있습니다.것을 하는 또 다른 효율적인 방법은 키워드 인수를 사용하는 것이지만, 그것들은 합법적인 python 단어여야 하기 때문에 공백이나 특별한 기호를 가질 수도 없고, 숫자로 이름을 시작할 수도 없습니다. 그러나 많은 사람들은 이것이 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

이 ,, 자, 첨, 첨, 첨, ,, ,, ,, ,, ,, 는, 는, 는, 는, 는, 는, so, so, so, so, ,, so, so, so, so, so, so, so, so, so, so, so, , so, so, so, so, so, so, so, so, so__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'}}}

참고: Python에서는 먼저 서브를 추가해야 합니다.

dictionary["dictionary_within_a_dictionary"] = {}

엔트리를 추가하기 전에.

기존 구문은 다음과 같습니다.d[key] = value키보드에 대괄호 키가 없는 경우 다음 작업을 수행할 수도 있습니다.

d.__setitem__(key, value)

''의 정의'는 ''의 정의''는__getitem__ ★★★★★★★★★★★★★★★★★」__setitem__methods는 자신의 클래스에서 대괄호 구문을 지원하도록 하는 방법입니다.Python에 대한 자세한 내용은 사전처럼 작동하는 클래스를 참조하십시오.

다음 중 하나를 작성할 수 있습니다.

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})

레퍼런스:식 'dict(d1, **d2)'에서 '**'는 무슨 뜻합니까?

이름이 이상하고 행동이 이상하지만 여전히 편리한 것도 있다.

이것.

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

이 질문은 이미 역겹게 답변이 되었지만, 제 코멘트가 많은 관심을 끌었기 때문에, 다음과 같은 답변이 있습니다.

기존 dict를 업데이트하지 않고 새 키 추가

키를 추가하고 (기존 사전을 변경하지 않고) 새 사전을 반환하는 방법을 알아보려면 다음 방법을 사용합니다.

python > = 3.5

new_dict = {**mydict, 'new_key': new_val}

python < 3.5

new_dict = dict(mydict, new_key=new_val)

이 방법에서는 python에서 유효한 식별자 이름의 규칙을 따라야 합니다.

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

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()★★★★★★ 。

여기에서는 볼 수 없었던 다른 방법이 있습니다.

>>> 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)

많은 유용한 사전 서브클래스와 래퍼로 구성된 Python의 모듈을 지적하는 것도 도움이 될 것 같습니다.특히, 다음과 같습니다.

누락된 값을 제공하기 위해 공장 함수를 호출하는 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]})

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

추가를 사용하지 않고 사전에 키 추가

        # Inserting/Updating single value
        # subscript notation method
        d['mynewkey'] = 'mynewvalue' # Updates if 'a' exists, else adds 'a'
        # OR
        d.update({'mynewkey': 'mynewvalue'})
        # OR
        d.update(dict('mynewkey'='mynewvalue'))
        # OR
        d.update('mynewkey'='mynewvalue')
        print(d)  # {'key': 'value', 'mynewkey': 'mynewvalue'}
        # To add/update multiple keys simultaneously, use d.update():
        x = {3:4, 5:6, 7:8}
        d.update(x)
        print(d) # {'key': 'value', 'mynewkey': 'mynewvalue', 3: 4, 5: 6, 7: 8}
        # update operator |= now works for dictionaries:
        d |= {'c':3,'d':4}
        # Assigning new key value pair using dictionary unpacking.
        data1 = {4:6, 9:10, 17:20}
        data2 = {20:30, 32:48, 90:100}
        data3 = { 38:"value", 99:"notvalid"}
        d = {**data1, **data2, **data3}
        # The merge operator | now works for dictionaries:
        data = data1 | {'c':3,'d':4}
        # Create a dictionary from two lists
        data = dict(zip(list_with_keys, list_with_values))

언급URL : https://stackoverflow.com/questions/1024847/how-can-i-add-new-keys-to-a-dictionary