사전을 복사하고 사본 만 편집하는 방법

누군가 나에게 이것을 설명해 주시겠습니까? 이것은 나에게 이해가되지 않습니다.

사전을 다른 사전에 복사하고 두 번째를 편집하면 둘 다 변경됩니다. 왜 이런 일이 발생합니까?

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict1
>>> dict2
{'key2': 'value2', 'key1': 'value1'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key2': 'WHY?!', 'key1': 'value1'}

파이썬은 절대로 객체를 절대로 복사 하지 않습니다 . 을 설정하면 dict2 = dict1객체가 동일한 정확한 dict 객체를 참조하게되므로 변경하면 객체에 대한 모든 참조가 현재 상태의 객체를 계속 참조합니다.

dict을 복사하려면 (드물지만)

dict2 = dict(dict1)

또는

dict2 = dict1.copy()

당신이 할당 할 때 dict2 = dict1, 당신의 사본을 제작하지 않습니다 dict1, 그것은 결과를 dict2위한 또 다른 이름 인 dict1.

사전과 같은 가변 유형을 복사하려면 모듈의 copy/ deepcopy를 사용 하십시오 copy.

import copy

dict2 = copy.deepcopy(dict1)

동안 dict.copy()과는 dict(dict1)복사본을 생성, 그들은 단지입니다 얕은 복사합니다. 깊은 사본 을 원한다면 copy.deepcopy(dict1)필수입니다. 예를 들면 :

>>> source = {'a': 1, 'b': {'m': 4, 'n': 5, 'o': 6}, 'c': 3}
>>> copy1 = x.copy()
>>> copy2 = dict(x)
>>> import copy
>>> copy3 = copy.deepcopy(x)
>>> source['a'] = 10  # a change to first-level properties won't affect copies
>>> source
{'a': 10, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy3
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> source['b']['m'] = 40  # a change to deep properties WILL affect shallow copies 'b.m' property
>>> source
{'a': 10, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy3  # Deep copy's 'b.m' property is unaffected
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}

Python copy모듈 문서 에서 얕은 사본과 깊은 사본에 대해 :

얕은 복사와 깊은 복사의 차이점은 복합 객체 (목록 또는 클래스 인스턴스와 같은 다른 객체를 포함하는 객체)에만 해당됩니다.

• 얕은 복사본은 새 복합 개체를 구성한 다음 가능한 한 원본 개체에서 찾은 개체에 참조를 삽입합니다.
• 딥 카피는 새 복합 객체를 구성한 다음 재귀 적으로 원본에서 찾은 객체의 카피를 복사합니다.

python 3.5 이상에서는 ** unpackaging 연산자를 사용하여 얕게 복사 할 수있는 쉬운 방법이 있습니다. Pep 448에 의해 정의 됨 .

>>>dict1 = {"key1": "value1", "key2": "value2"}
>>>dict2 = {**dict1}
>>>print(dict2)
{'key1': 'value1', 'key2': 'value2'}
>>>dict2["key2"] = "WHY?!"
>>>print(dict1)
{'key1': 'value1', 'key2': 'value2'}
>>>print(dict2)
{'key1': 'value1', 'key2': 'WHY?!'}

** 사전을 새로운 사전에 풀고 dict2에 할당합니다.

각 사전에 고유 한 ID가 있는지 확인할 수도 있습니다.

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

딥 카피가 필요한 경우 copy.deepcopy () 는 여전히가는 길입니다.

가장 좋고 가장 쉬운 방법 복사본 생성 (A)의 딕셔너리를 모두 파이썬 2.7과 3 입니다 ...

단순 (단일 레벨) 사전의 사본을 작성하려면 다음을 수행하십시오.

1. 기존 dict를 가리키는 참조를 생성하는 대신 dict () 메소드 사용 .

my_dict1 = dict()
my_dict1["message"] = "Hello Python"
print(my_dict1)  # {'message':'Hello Python'}

my_dict2 = dict(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

2. 파이썬 사전 의 내장 update () 메소드 사용.

my_dict2 = dict()
my_dict2.update(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

중첩되거나 복잡한 사전의 사본을 작성하려면 다음을 수행하십시오.

일반적인 얕은 복사 및 깊은 복사 작업을 제공하는 내장 복사 모듈을 사용하십시오 . 이 모듈은 Python 2.7과 3 모두에 있습니다. *

import copy

my_dict2 = copy.deepcopy(my_dict1)

사전 이해력으로 새로운 사전을 만들 수도 있습니다. 이렇게하면 사본을 가져 오지 않아도됩니다.

dout = dict((k,v) for k,v in mydict.items())

물론 파이썬> = 2.7에서는 다음을 수행 할 수 있습니다.

dout = {k:v for k,v in mydict.items()}

그러나 이전 버전과의 호환성을 위해서는 최고의 방법이 더 좋습니다.

제공된 다른 솔루션 외에도 **사전을 빈 사전에 통합하는 데 사용할 수 있습니다 ( 예 :

shallow_copy_of_other_dict = {**other_dict}.

이제 "의"얕은 "사본을 갖게됩니다 other_dict.

귀하의 예에 적용 :

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = {**dict1}
>>> dict2
{'key1': 'value1', 'key2': 'value2'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key1': 'value1', 'key2': 'value2'}
>>>

포인터 : 얕고 깊은 사본의 차이점

파이썬에서 대 입문은 객체를 복사하지 않고 대상과 객체 사이에 바인딩을 만듭니다.

따라서 참조 하는 객체와 객체 dict2 = dict1사이에 다른 바인딩이 발생 합니다.dict2dict1

dict을 복사하려면을 사용할 수 있습니다 copy module. 복사 모듈에는 두 가지 인터페이스가 있습니다.

copy.copy(x)
Return a shallow copy of x.

copy.deepcopy(x)
Return a deep copy of x.

얕은 복사와 깊은 복사의 차이점은 복합 객체 (목록 또는 클래스 인스턴스와 같은 다른 객체를 포함하는 객체)에만 해당됩니다.

얕은 사본 객체에 그것에 대한 참조가 원래 발견 삽입 (가능한 범위까지) 한 후 새로운 화합물 및 객체를 구성한다.

깊은 복사 객체가 원래의 발견의 그것으로 새로운 복합 객체하고, 반복적으로 삽입 복사본을 생성합니다.

예를 들어 python 2.7.9에서 :

>>> import copy
>>> a = [1,2,3,4,['a', 'b']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> a.append(5)
>>> a[4].append('c')

결과는 다음과 같습니다.

>>> a
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> b
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c']]
>>> d
[1, 2, 3, 4, ['a', 'b']]

dict추가 키워드 인수로 생성자를 호출하여 새로 생성 된 사본을 한 번에 복사하고 편집 할 수 있습니다 .

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict(dict1, key2="WHY?!")
>>> dict1
{'key2': 'value2', 'key1': 'value1'}
>>> dict2
{'key2': 'WHY?!', 'key1': 'value1'}

C 배경에서 왔기 때문에 처음에는 혼란 스러웠습니다.

C에서 변수는 정의 된 유형을 가진 메모리의 위치입니다. 변수에 할당하면 데이터가 변수의 메모리 위치에 복사됩니다.

그러나 파이썬에서 변수는 객체에 대한 포인터처럼 작동합니다. 따라서 하나의 변수를 다른 변수에 할당해도 사본이 만들어지지 않으며 변수 이름이 동일한 객체를 가리키게됩니다.

파이썬의 모든 변수 ( dict1또는 내부 str또는 __builtins__내부에 숨겨진 플라토닉 "객체"에 대한 포인터입니다.

을 설정 하면 동일한 객체 (또는 메모리 위치 또는 원하는 비유)를 dict1 = dict2가리 킵니다 . 이제 참조하는 객체는 참조하는 객체 와 동일합니다 .dict1dict2dict1dict2

확인할 수 있습니다 : dict1 is dict2해야합니다 True. 또한와 id(dict1)같아야합니다 id(dict2).

당신이 원하는 dict1 = copy(dict2), 또는 dict1 = deepcopy(dict2).

copy와 deepcopy? 의 차이점 (목록에서 지적 했습니까?)의 요소도 사본 deepcopy인지 확인하십시오 dict2.

나는 deepcopy많이 사용하지 않습니다 -일반적으로 (필자의 의견으로는) 필요한 코드를 작성하는 것은 좋지 않습니다 .

dict1기본 사전 객체를 참조하는 기호입니다. 에 할당 하면 동일한 참조가 할당 dict1됩니다 dict2. dict2기호 를 통해 키 값을 변경하면 기본 개체가 변경되어에 영향을줍니다 dict1. 혼란 스럽습니다.

참조보다 불변 값을 추론하는 것이 훨씬 쉬우므로 가능할 때마다 사본을 만드십시오.

person = {'name': 'Mary', 'age': 25}
one_year_later = {**person, 'age': 26}  # does not mutate person dict

문법적으로 다음과 같습니다.

one_year_later = dict(person, age=26)

dict2 = dict1사전을 복사하지 않습니다. 단순히 프로그래머에게 dict2동일한 사전을 참조 하는 두 번째 방법 ( )을 제공합니다 .

>>> dict2 = dict1
# dict2 is bind to the same Dict object which binds to dict1, so if you modify dict2, you will modify the dict1

Dict 객체를 복사하는 방법은 여러 가지가 있습니다.

dict_1 = {
           'a':1,
           'b':2
         }
dict_2 = {}
dict_2.update(dict_1)

다른 사람들이 설명했듯이 내장 기능은 dict원하는 것을하지 않습니다. 그러나 Python2 (및 아마도 3)에서도 ValueDict복사 하는 클래스를 쉽게 만들 =수 있으므로 원본이 변경되지 않을 것입니다.

class ValueDict(dict):

    def __ilshift__(self, args):
        result = ValueDict(self)
        if isinstance(args, dict):
            dict.update(result, args)
        else:
            dict.__setitem__(result, *args)
        return result # Pythonic LVALUE modification

    def __irshift__(self, args):
        result = ValueDict(self)
        dict.__delitem__(result, args)
        return result # Pythonic LVALUE modification

    def __setitem__(self, k, v):
        raise AttributeError, \
            "Use \"value_dict<<='%s', ...\" instead of \"d[%s] = ...\"" % (k,k)

    def __delitem__(self, k):
        raise AttributeError, \
            "Use \"value_dict>>='%s'\" instead of \"del d[%s]" % (k,k)

    def update(self, d2):
        raise AttributeError, \
            "Use \"value_dict<<=dict2\" instead of \"value_dict.update(dict2)\""


# test
d = ValueDict()

d <<='apples', 5
d <<='pears', 8
print "d =", d

e = d
e <<='bananas', 1
print "e =", e
print "d =", d

d >>='pears'
print "d =", d
d <<={'blueberries': 2, 'watermelons': 315}
print "d =", d
print "e =", e
print "e['bananas'] =", e['bananas']


# result
d = {'apples': 5, 'pears': 8}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
d = {'apples': 5, 'pears': 8}
d = {'apples': 5}
d = {'watermelons': 315, 'blueberries': 2, 'apples': 5}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
e['bananas'] = 1

# e[0]=3
# would give:
# AttributeError: Use "value_dict<<='0', ..." instead of "d[0] = ..."

여기에서 논의 된 lvalue 수정 패턴을 참조하십시오 : lvalue 수정을위한 Python 2.7-clean 구문 . 주요 관찰이다 str하고 int(실제로 후드 아래 불변의 객체 있는데도) 파이썬에서 값으로 동작합니다. 당신이 그것을 관찰하는 동안, str또는 에 대해 마술 적으로 특별한 것이 없다는 것도 관찰하십시오 int. dict똑같은 방식으로 사용될 수 있고, ValueDict이해가 되는 많은 경우를 생각할 수 있습니다 .

딥 카피보다 3 배 이상 빠른 json 구문을 따르는 dicts에있는 다음 코드

def CopyDict(dSrc):
    try:
        return json.loads(json.dumps(dSrc))
    except Exception as e:
        Logger.warning("Can't copy dict the preferred way:"+str(dSrc))
        return deepcopy(dSrc)

변수에 할당하지 않고 클래스의 사전 속성을 딥 카피하려고 할 때 특이한 동작이 발생했습니다.

new = copy.deepcopy(my_class.a)작동하지 않습니다. 즉 수정 new수정my_class.a

그러나 당신이 old = my_class.a하고 new = copy.deepcopy(old)완벽하게 작동 한다면 수정 new은 영향을 미치지 않습니다my_class.a

왜 이런 일이 발생하는지 잘 모르겠지만 시간을 절약하는 데 도움이되기를 바랍니다. :)

dict2 = dict1이므로 dict2는 dict1에 대한 참조를 보유합니다. dict1과 dict2는 모두 메모리에서 동일한 위치를 가리 킵니다. 파이썬에서 가변 객체로 작업하는 동안 이것은 정상적인 경우입니다. 파이썬에서 가변 객체로 작업 할 때 디버깅하기가 어렵 기 때문에주의해야합니다. 다음과 같은 예입니다.

 my_users = {
        'ids':[1,2],
        'blocked_ids':[5,6,7]
 }
 ids = my_users.get('ids')
 ids.extend(my_users.get('blocked_ids')) #all_ids
 print ids#output:[1, 2, 5, 6, 7]
 print my_users #output:{'blocked_ids': [5, 6, 7], 'ids': [1, 2, 5, 6, 7]}

이 예제의 목적은 차단 된 ID를 포함하여 모든 사용자 ID를 얻는 것입니다. 우리는 ids 변수에서 얻었지만 우연히 my_users 의 값을 업데이트했습니다 . 당신이 확장 할 때 식별자 와 blocked_ids의 때문에 my_users가 업데이트되었다 ID를 참조 my_users .

for 루프를 사용하여 복사 :

orig = {"X2": 674.5, "X3": 245.0}

copy = {}
for key in orig:
    copy[key] = orig[key]

print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 674.5, 'X3': 245.0}
copy["X2"] = 808
print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 808, 'X3': 245.0}

직접 사용할 수 있습니다 :

dict2 = eval(repr(dict1))

여기서 dict2 오브젝트는 dict1의 독립 사본이므로 dict1에 영향을주지 않고 dict2를 수정할 수 있습니다.

이것은 모든 종류의 객체에서 작동합니다.