Jak skopiować słownik i edytować tylko kopię

Czy ktoś może mi to wyjaśnić? To nie ma dla mnie żadnego sensu.

Kopiuję słownik do innego i edytuję drugi i oba są zmieniane. Dlaczego to się dzieje?

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

Python nigdy niejawnie kopiuje obiekty. Po ustawieniu dict2 = dict1powoduje, że odnoszą się one do tego samego dokładnie obiektu dict, więc po zmutowaniu wszystkie odniesienia do niego będą odnosić się do obiektu w jego bieżącym stanie.

Jeśli chcesz skopiować dykt (co jest rzadkie), musisz to zrobić jawnie

dict2 = dict(dict1)

lub

dict2 = dict1.copy()

Kiedy przypisujesz dict2 = dict1, nie tworzysz kopii dict1, skutkuje dict2to po prostu inną nazwą dla dict1.

Aby skopiować zmienne typów jak słowniki użytku copy/ deepcopyz copymodułu.

import copy

dict2 = copy.deepcopy(dict1)

Podczas gdy dict.copy()i dict(dict1)generuje kopię, są to tylko płytkie kopie. Jeśli potrzebujesz głębokiej kopii, copy.deepcopy(dict1)jest wymagana. Przykład:

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

Jeśli chodzi o płytkie i głębokie kopie, z dokumentacji modułu Pythoncopy :

Różnica między płytkim a głębokim kopiowaniem dotyczy tylko obiektów złożonych (obiektów zawierających inne obiekty, takich jak listy lub instancje klas):

• Płytka kopia konstruuje nowy obiekt złożony, a następnie (w możliwym zakresie) wstawia do niego odwołania do obiektów znalezionych w oryginale.
• Głęboka kopia konstruuje nowy obiekt złożony, a następnie rekurencyjnie wstawia do niego kopie obiektów znalezionych w oryginale.

W Pythonie 3.5+ istnieje łatwiejszy sposób na uzyskanie płytkiej kopii za pomocą ** operatora rozpakowywania. Zdefiniowany przez 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?!'}

** rozpakowuje słownik do nowego słownika, który jest następnie przypisywany do dict2.

Możemy również potwierdzić, że każdy słownik ma odrębny identyfikator.

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

Jeśli potrzebna jest głęboka kopia, to copy.deepcopy () jest nadal dobrym rozwiązaniem.

Najlepszy i najprostszy sposób, aby utworzyć kopię o dict zarówno w Pythonie 2.7 i 3 są ...

Aby utworzyć kopię prostego (jednopoziomowego) słownika:

1. Za pomocą metody dict () zamiast generować odwołanie wskazujące na istniejący dykt.

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. Korzystanie z wbudowanej metody update () słownika python.

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

Aby utworzyć kopię zagnieżdżonego lub złożonego słownika:

Użyj wbudowanego modułu kopiowania , który zapewnia ogólne płytkie i głębokie operacje kopiowania. Ten moduł jest obecny zarówno w Pythonie 2.7, jak i 3. *

import copy

my_dict2 = copy.deepcopy(my_dict1)

Możesz także utworzyć nowy słownik ze zrozumieniem słownika. Pozwala to uniknąć importowania kopii.

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

Oczywiście w python> = 2.7 możesz zrobić:

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

Ale dla kompatybilności wstecznej najlepsza metoda jest lepsza.

Oprócz innych dostarczonych rozwiązań można użyć **do zintegrowania słownika z pustym słownikiem, np.

shallow_copy_of_other_dict = {**other_dict}.

Teraz będziesz mieć „płytką” kopię other_dict.

Dotyczy twojego przykładu:

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

Wskaźnik: Różnica między płytkimi a głębokimi kopiami

Instrukcje przypisania w Pythonie nie kopiują obiektów, tworzą powiązania między celem a obiektem.

Więc dict2 = dict1, wynika inny wiązania pomiędzy dict2i obiekt, który dict1odnosi się do.

jeśli chcesz skopiować nagranie, możesz użyć copy module. Moduł kopiowania ma dwa interfejsy:

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

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

Różnica między płytkim a głębokim kopiowaniem dotyczy tylko obiektów złożonych (obiektów zawierających inne obiekty, takich jak listy lub instancje klas):

Płytkie kopii tworzy nowy obiekt, a następnie związek (w zakresie możliwym) wkłada odniesień do niej na przedmioty znajdujące się w oryginale.

ZA Głęboka kopia konstruuje nowy obiekt związek, a następnie rekurencyjnie, wkładki do niego kopie obiektów znalezionych w oryginale.

Na przykład w 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 wynikiem jest:

>>> 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']]

Możesz skopiować i edytować nowo utworzoną kopię za jednym razem, wywołując dictkonstruktor z dodatkowymi argumentami słów kluczowych:

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

Początkowo to też mnie zdezorientowało, ponieważ pochodziłem z języka C.

W C zmienna jest lokalizacją w pamięci o zdefiniowanym typie. Przypisanie do zmiennej kopiuje dane do lokalizacji pamięci zmiennej.

Ale w Pythonie zmienne działają bardziej jak wskaźniki do obiektów. Zatem przypisanie jednej zmiennej do drugiej nie tworzy kopii, po prostu sprawia, że ​​nazwa zmiennej wskazuje na ten sam obiekt.

Każda zmienna w pythonie (rzeczy takie jak dict1lub strlub__builtins__ jest wskaźnikiem do jakiegoś ukrytego platońskiego „obiektu” wewnątrz maszyny.

Jeśli ustawisz dict1 = dict2, po prostu wskażesz dict1ten sam obiekt (lub lokalizację pamięci lub dowolną analogię), jak dict2. Teraz obiekt, do którego następuje odwołanie, dict1to ten sam obiekt, do którego odnosi siędict2 .

Możesz sprawdzić: dict1 is dict2powinno być True. Ponadto id(dict1)powinien być taki sam jakid(dict2) .

Chcesz dict1 = copy(dict2)lubdict1 = deepcopy(dict2) .

Różnica między copyi deepcopy? deepcopyupewni się, że elementydict2 (czy wskazałeś na listę?) są również kopiami.

Nie używam deepcopydużo - zwykle słabą praktyką jest pisanie kodu, który tego wymaga (moim zdaniem).

dict1jest symbolem, który odwołuje się do podstawowego obiektu słownika. Przypisanie dict1do dict2jedynie przypisania tego samego odwołania. Zmiana wartości klucza za pomocą dict2symbolu zmienia podstawowy obiekt, co również ma wpływ dict1. To jest mylące.

O wiele łatwiej jest wnioskować o niezmiennych wartościach niż referencjach, więc rób kopie, gdy tylko jest to możliwe:

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

Jest to składniowo to samo, co:

one_year_later = dict(person, age=26)

dict2 = dict1nie kopiuje słownika. To po prostu daje programiście drugi sposób ( dict2) na odniesienie do tego samego słownika.

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

Istnieje wiele sposobów kopiowania obiektu Dict, po prostu używam

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

Jak wyjaśnili inni, wbudowane narzędzie dictnie robi tego, co chcesz. Ale w Python2 (i prawdopodobnie również 3) możesz łatwo utworzyć ValueDictklasę, z =którą będziesz kopiować, aby mieć pewność, że oryginał się nie zmieni.

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] = ..."

Proszę odnieść się do omawianego tutaj wzoru modyfikacji wartości: Python 2.7 - czysta składnia dla modyfikacji wartości . Kluczem jest to, że obserwacja stri intzachowywać się jak wartości w Pythonie (choć są one rzeczywiście niezmienne obiekty pod maską). Obserwując to, zauważ również, że nic nie jest magicznie wyjątkowe w strlub int. dictmogą być używane w ten sam sposób i mogę myśleć o wielu przypadkach, w których ValueDictma to sens.

poniższy kod, który jest na dyktando, który postępuje zgodnie ze składnią Json ponad 3 razy szybciej niż deepcopy

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)

natknąłem się na szczególne zachowanie podczas próby głębokiego skopiowania właściwości słownika klasy bez przypisywania jej do zmiennej

new = copy.deepcopy(my_class.a)nie działa, tj. modyfikowanie newmodyfikacjimy_class.a

ale jeśli to zrobisz, old = my_class.aa następnie new = copy.deepcopy(old)zadziała to idealnie, tj. modyfikacja newnie ma wpływumy_class.a

Nie jestem pewien, dlaczego tak się dzieje, ale mam nadzieję, że pomoże to zaoszczędzić kilka godzin! :)

ponieważ dict2 = dict1, dict2 zawiera odniesienie do dict1. Zarówno dict1, jak i dict2 wskazują to samo miejsce w pamięci. Jest to normalny przypadek podczas pracy ze zmiennymi obiektami w Pythonie. Podczas pracy ze zmiennymi obiektami w Pythonie musisz być ostrożny, ponieważ trudno jest debugować. Tak jak w poniższym przykładzie.

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

Ten przykładowy zamiar polega na uzyskaniu wszystkich identyfikatorów użytkowników, w tym identyfikatorów zablokowanych. Otrzymaliśmy to ze zmiennej ids, ale również przypadkowo zaktualizowaliśmy wartość my_users . kiedy rozszerzyłeś identyfikatory za pomocą block_ids, my_users zostali zaktualizowani, ponieważ identyfikatory odnoszą się do my_users .

Kopiowanie przy użyciu pętli 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}

Możesz użyć bezpośrednio:

dict2 = eval(repr(dict1))

gdzie obiekt dict2 jest niezależną kopią dict1, więc możesz modyfikować dict2 bez wpływu na dict1.

Działa to dla każdego rodzaju obiektu.