[python 심화] 10. copy & deep copy

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

 

<이전 글>

https://silvercoding.tistory.com/26

[python 심화] 9. 변수 범위, Closure, Decorator

 

 

- 얕은 복사 & is  vs  __eq__ (==) 

x = {'name': 'Kim','age': 33, 'city' : 'Seoul'}
y = x  # ---> 얕은 복사

우선 x에 딕셔너리를 저장한다. 그다음 단순한 복사를 한다. 

print('EX2-1', id(x), id(y))  
print('EX2-2 - ', x == y)
print('EX2-3 - ', x is y)
print('EX2-4 - ', x, y)

 EX2-1 2324412065760 2324412065760 

우선 id 값을 출력해보니 두 값이 완전히 같았다. 

 EX2-2 -  True 

 EX2-3 -  True 

2-2와 2-3은 직관적으로 봐도 x와 y가 같은지를 물어보는 코드인 것 같다. 하지만 다른 종류의 확인법이다. __eq__ (==) 와 같은 경우는 x와 y의 값이 같은지를 확인하는 것이고 , is는 x와 y의 id값이 같은지를 확인하는 것이다. 

 

** 정리 

==(__eq__) : 값을 비교  vs  is : 객체 주소 (정체성) 비교

 

 EX2-4 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul'} {'name': 'Kim', 'age': 33, 'city': 'Seoul'} 

위 예제에서는 값, id 모두 같다. x와 y를 출력하면 당연한 결과로 같은 딕셔너리가 나오는 것을 볼 수 있다. 

 

x의 값을 수정하거나 추가하면 y도 바뀔까? id값이 같으므로 바뀔 것으로 추정할 수 있다. 

x['class'] = 10 
print('EX2-5 - ', x, y)

 

 EX2-5 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 

x에 값을 추가했더니 y도 똑같이 추가되는 것을 알 수 있다. 

 

z = {'name': 'Kim','age': 33, 'city' : 'Seoul', 'class' : 10}

새 딕셔너리 객체를 만들어 본다. 값은 x와 같도록! 

print('EX2-6 - ', x, z)
print('EX2-7 - ', x is z)  # 같은 객체냐 
print('EX2-8 - ', x is not z)  
print('EX2-9 - ', x == z)  # 값이 같냐

 EX2-6 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 
 EX2-7 -  False 
 EX2-8 -  True 
 EX2-9 -  True 

x와 z를 비교해 보면 id값은 다르고, 값만 같다고 나오는 것을 볼 수 있다. 이 경우에는 x의 값을 변경하여도 z의 값은 변하지 않을 것이다. (당연한 소리) 

 

 

*** cf ) 튜플 (불변형) 비교 

tuple1 = (10, 15, [100, 1000])
tuple2 = (10, 15, [100, 1000])

print('EX3-1 - ', id(tuple1), id(tuple2))
print('EX3-2 - ', tuple1 is tuple2)
print('EX3-3 - ', tuple1 == tuple2)
print('EX3-4 - ', tuple1.__eq__(tuple2))

 EX3-1 -  2324415315832 2324415315544 
 EX3-2 -  False 
 EX3-3 -  True 
 EX3-4 -  True 

 

 

 

 

- Copy & DeepCopy (얕은 복사 , 깊은 복사) 

tl1 = [10, [100, 105], (5, 10, 15)]
tl2 = tl1
tl3 = list(tl1)

리스트 안에 숫자, 리스트, 튜플을 각각 넣은 후, tl2에는 얕은 복사를 , tl3에는 list의 인자에 넣어 새 객체를 생성해 준다. 

print('EX4-1 - ', tl1 == tl2)
print('EX4-2 - ', tl1 is tl2)
print('EX4-3 - ', tl1 == tl3)
print('EX4-4 - ', tl1 is tl3)

 EX4-1 -  True 
 EX4-2 -  True 
 EX4-3 -  True 
 EX4-4 -  False 

4-3과 4-4와 같은 경우는 값은 같지만, 객체는 다르다는 것을 알 수 있다. 

 

 

tl1.append(1000)
tl1[1].remove(105)

tl1에 1000을 추가하고, 1번째 리스트에서 105를 제거하면 어떻게 될까 ! 

print('EX4-5 - ', tl1)
print('EX4-6 - ', tl2)
print('EX4-7 - ', tl3)

 EX4-5 -  [10, [100], (5, 10, 15), 1000] 
 EX4-6 -  [10, [100], (5, 10, 15), 1000] 
 EX4-7 -  [10, [100], (5, 10, 15)] 

tl2는 같은 객체로 복사되어 있기 때문에 tl1과 같은 것을 볼 수 있다. 그런데 tl3는 반만 똑같다! 왜 그럴까? 

print(id(tl1[1])) # tl1과 tl3의 id는 다르지만 안에 있는 리스트의 id값은 같다. ! 
print(id(tl3[1]))

 2324415643528 
 2324415643528 

아 . tl1과 tl3 자체 객체의 id값은 달랐지만, 그 안에 있는 1번째 리스트의 id값은 같았다. 점점 이 방법으로 하는 복사의 허점이 보이기 시작한다. 

 

tl1[1] += [110, 120]
tl1[2] += (110, 120)

tl1의 리스트와 튜플에 각각 값을 추가해준다. 

print('EX4-8 - ', tl1)
print('EX4-9 - ', tl2) # 튜플 재 할당 (깩체 새로 생성) ---> 데이터가 현저히 많을 떈 주의 해야 한다. 객체를 새로 생성한다는 것은 데이터 손실이 있을 수도 있고 , 메모리를 더 차지할 수도 있게 되기 때문 !
print('EX4-10 - ', tl3)

 EX4-8 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-9 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-10 -  [10, [100, 110, 120], (5, 10, 15)] 

우선 tl1, tl2는 여기서도 똑같이 움직인 다는 것을 알 수 있다. 그런데 tl3에서는 조금 이상한 현상이 일어났다. 리스트는 값이 추가되었지만 , 튜플은 값이 추가되지 않았다. 답은 코드 주석에 써있듯이, 튜플은 객체를 새로 생성하여 재 할당이 되기 때문인데, 이해를 위하여 id값을 출력해보았다. 

 

# 리스트, 튜플에 값 추가 전 
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

...

# 리스트, 튜플에 값 추가 후
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

 1367137568664 
 1367137568664 
 1367137568664 

 

 1367137218056 
 1367137218056 
 1367137568664 

리스트처럼 tl1, tl3의 튜플 id값은 같았다. 튜플에선 이게 이슈가 되는 것이다! tl1[2] += (110, 120) <--- 이 코드가 실행되면 튜플이 재할당되어 새 객체가 생성된다. 그래서 id값을 보면 이 코드 전과 후의 tl1, tl2 id값이 달라진 것을 볼 수 있다. 그래서 전과 같은 id값을 가진 tl3의 튜플은 변화하지 않는 것이다. 

 

 

 

 

*** copy & Deep copy (깊은 복사) 실습해보기 

(ex) 장바구니 클래스 

class Basket:
    def __init__(self, products=None):
        if products is None:
            self._products = []
        else:
            self._products = list(products)  # 새로운 객체 생성

    def put_prod(self, prod_name):
        self._products.append(prod_name)

    def del_prod(self, prod_name):
        self._products.remove(prod_name)

_products에 물건을 담고, put_prod 메소드로 물건 추가 , del_prod 메소드로 물건 삭제를 하는 클래스 생성! 

import copy

basket1 = Basket(['Apple', 'Bag', 'TV', 'Snack', 'Water'])
basket2 = copy.copy(basket1)  # 얕은 복사 
basket3 = copy.deepcopy(basket1)  # 깊은 복사 ---> 객체 안에 있는 인스턴스 변수까지 참조

copy를 import하여 얕은 복사(copy.copy) 와 깊은 복사(copy.deepcopy) 를 해본다. 

print('EX5-1 - ', id(basket1), id(basket2), id(basket3))
print('EX5-2 - ', id(basket1._products), id(basket2._products), id(basket3._products))

 EX5-1 -  1367137770520 1367137770464 1367137771304 
 EX5-2 -  1367137799240 1367137799240 1367137626888 

copy를 사용하면 객체 자체는 모두 다르게 나오는 것을 볼 수 있다. EX5-2에서 얕은 복사와 깊은복사의 차이점이 보인다. deepcopy는 객체 안에 있는 인스턴스 변수까지 참조를 하기 때문에 변수의 객체까지 id의 값이 다르다! 

 

basket1.put_prod('Orange')
basket2.del_prod('Snack')

basket1에 Orange를 넣고, Snack을 삭제하면 어떻게 변하는지 확인해 보자! 

# 빅데이터나, 웹개발할 떄 주의해야 한다. 
print('EX5-3 - ', basket1._products)
print('EX5-4 - ', basket2._products)  
print('EX5-5 - ', basket3._products)

 EX5-3 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-4 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-5 -  ['Apple', 'Bag', 'TV', 'Snack', 'Water'] 

이렇게 basket1과 basket2는 서로 영향을 받는다. 깊은복사를 한 basket3는 영향을 받지 않는다. 

이는 빅데이터 또는 웹개발을 할 때 주의해야 한다. 예를 들어 빅데이터 분석을 할 때 원본은 손상시키지 않고 복사를 하여 전처리를 할 경우 얕은 복사를 하게 되면 생각만 해도 아찔하다. 

 

 

 

- 함수 매개변수 전달 주의 

def mul(x, y):
    x += y
    return x

x에 y를 더해서 x에 넣고, x를 return해주는 mul 함수 생성 

x = 10 
y = 5

print('EX6-1 - ', mul(x, y), x, y)

 EX6-1 -  15 10 5 

함수 안의 x가 15라고 해서 전역변수 x의 값이 변경되지는 않는다. 

 

 

* 가변형 a -> 원본 데이터 변경/ 함수에 전달할 때 원본의 주소까지 넘김

a = [10, 100]
b = [5, 10]

print('Ex6-2 - ', mul(a, b), a, b)  # ---> 확장! ! ! ! !

 Ex6-2 -  [10, 100, 5, 10] [10, 100, 5, 10] [5, 10] 

하지만 가변형인 리스트 타입의 a를 mul에 넣으면 전역변수인 a의 값까지 변해버린다. 즉 원본데이터가 변경되는 것이다. 함수에 이 데이터를 전달할 때 원본의 주소까지 넘기기 때문이다. 

 

 

* 불변형 c ---> 원본 데이터 변경 안됨

c = (10, 100)
d = (5, 10)
print('Ex6-2 - ', mul(c, d), c, d)

불변형인 튜플타입의 c같은 경우에는 원본 데이터의 변경이 되지 않는다. 위에서 배웠듯이 튜플의 내용이 갱신될 때는 새로운 주소에 할당이 되기 때문이다. 

 

 

 

 

- 파이썬 불변형 예외 

: str, bytes, frozenset, Tuple ---> 사본 생성 X ---> 참조 반환 (같은 값이면 id 도 같다) 

tt1 = (1, 2, 3, 4, 5)
tt2 = tuple(tt1)
tt3 = tt1[:]

이번엔 튜플을 각각 다른 방법으로 복사하여 tt2와 tt3를 생성하였다. 

print('EX7-1 - ', tt1 is tt2, id(tt1), id(tt2))
print('EX7-2 - ', tt1 is tt3, id(tt1), id(tt3))

 EX7-1 -  True 1367134857000 1367134857000 
 EX7-2 -  True 1367134857000 1367134857000 

리스트는 위와 같은 방법으로 객체를 생성하면 새로운 주소가 부여됐었다. 튜플은 불변형이므로 같은 값이면 id는 같다. 따라서 모든 id값이 같게 나왔다. 튜플은 불변형이기 때문에 튜플에 튜플을 더할 때 기존 튜플에 값이 추가되는 개념이기 보다는 새로운 튜플 객체가 만들어지는 것이라고 보면 된다.  

 

tt4 = (10, 20, 30, 40, 50)
tt5 = (10, 20, 30, 40, 50)
ss1 = 'Apple'
ss2 = 'Apple'

튜플과 또다른 불변형 str로 검증을 해보고 마친다. 

print('EX7-3 - ', tt4 is tt5, tt4 == tt5, id(tt4), id(tt5))
print('EX7-4 - ', ss1 is ss2, ss1 == ss2, id(ss1), id(ss2))

 EX7-3 -  True True 1367137216648 1367137216648 
 EX7-4 -  True True 1367137769320 1367137769320 

값이 같으면 다른 변수에 따로 생성을 해도 같은 주소를 갖고 있다는 것을 알 수 있다.