새싹프로그래머의 이야기

코딩 테스트 연습을 하던 중 다음과 같은 상황을 맞이하여 엄청 당황했었습니다.

s = [1,2,3]
for i in range(len(s)):
    a = s
    print(a,s)
    a.pop()

위 코드를 동작 시켰을 때, 제가 기대한 결과는 a라는 list에만 변화가 생기는 것이었습니다. 하지만 다음과 같은 결과가 나온 것입니다.

a: [1, 2, 3] s: [1, 2, 3]
a: [1, 2] s: [1, 2]
a: [1] s: [1]

파이썬의 copy 개념이 제대로 잡혀있지 않아 발생한 문제였습니다.

copy가 동작하는 방식은 데이터가 immutable / mutable 인지 그리고 shallow copy / deep copy인지에 따라 달라집니다.

• immutable한 자료형은 int형, str형 과 같은 자료형이며 mutable한 자료형은 list, set, dictionary와 같은 자료형입니다.
• shallow copy에는 '=', [:] , copy.copy(), 객체.copy() 연산이 있습니다.

shallow copy일 경우, 다음과 같이 동작합니다.

서로 다른 변수가 같은 객체를 참조하고 있는 형태 입니다. 바로 문제가 발생했던 상황이죠.

변수가 immutable할 경우 이 상황에서 문제가 발생하지 않습니다. immutable한 자료형은 바뀌지 않기 때문에 데이터에 변화가 생길 경우 새로운 객체가 생성됩니다.

하지만 문제는 mutable한 자료형에서 발생합니다. mutable한 자료형은 말 그대로 바뀔 수 있기 때문에 객체 자체가 바뀌게 됩니다.

코드로 살펴보겠습니다.

<immutable한 자료형에서의 shallow copy>

a = 3
b = a

print('a,b:',a,b)
print('ID of a and b:',id(a),id(b))

# a,b: 3 3
# ID of a and b: 140423687498096 140423687498096

b = 5
print('a,b:',a,b)
print('ID of a and b:',id(a),id(b))

# a,b: 3 5
# ID of a and b: 140654810294640 140654810294704

처음에는 동일한 객체를 참조하고 있지만, 값이 변하게 되면서 b가 새로운 객체를 참조하고 있음을 알 수 있습니다.

<mutable한 자료형에서의 shallow copy>

listA = [1,2,3]
listB = listA

print('listA,listB:',listA,listB)
print('ID of listA and listB:',id(listA),id(listB))

# listA,listB: [1, 2, 3] [1, 2, 3]
# ID of listA and listB: 140613739648320 140613739648320

listB.append([1,2,3])
print('listA,listB:',listA,listB)
print('ID of listA and listB:',id(listA),id(listB))

# listA,listB: [1, 2, 3, [1, 2, 3]] [1, 2, 3, [1, 2, 3]]
# ID of listA and listB: 140613739648320 140613739648320

mutable한 자료형의 경우, 객체가 새로 생성되는 것이 아니라 객체 자체에서 변화가 생깁니다. 

저는 이러한 것을 고려하지 않고 '=' 을 통해 shallow copy를 하였기 때문에 문제가 발생했던 것이었습니다.

이러한 문제를 [:]을 통해 간단히 해결할 수 있습니다.(완벽한 방식은 아닙니다.)

listA = [1,2,3]
listB = listA[:]

print('listA,listB:',listA,listB)
print('ID of listA and listB:',id(listA),id(listB))

# listA,listB: [1, 2, 3] [1, 2, 3]
# ID of listA and listB: 140613739648320 140613739648320

listB[0] = 99
print('listA,listB:',listA,listB)
print('ID of listA and listB:',id(listA),id(listB))

# listA,listB: [1, 2, 3] [99, 2, 3]
# ID of listA and listB: 140457913193792 140457913193600

listB.append([1,2,3])
print('listA,listB:',listA,listB)
print('ID of listA and listB:',id(listA),id(listB))

# listA,listB: [1, 2, 3] [99, 2, 3, [1, 2, 3]]
# ID of listA and listB: 140457913193792 140457913193600

listA = listB[:]

listB[3].append(999)

print('listA,listB:',listA,listB)
# ID of listA and listB: 140524217406784 140524217406592
# listA,listB: [99, 2, 3, [1, 2, 3, 999]] [99, 2, 3, [1, 2, 3, 999]]

보시면 [:]를 활용할 경우, listA와 listB의 주소가 다르기 때문에 Deep copy로 보이기도 합니다.

하지만 마지막을 보시면 [1,2,3] 객체에 999를 append하였을 때 두 리스트 모두 반영되는 것을 알 수 있습니다.

따라서, 완벽한 방식은 아니지요. 하지만 때에 따라 활용할 수는 있을 것 같습니다.

해결 방안

• 자료형을 고려하여 shallow copy와 deep copy를 적절히 사용하는 것이 가장 좋은 방법이라고 생각합니다.

Reference

https://blockdmask.tistory.com/576

파이썬 알고리즘 강의를 듣던 중 generator가 메모리 효율성에 큰 영향을 미친다는 얘기를 듣고 한번 정리해보고자 합니다.

generator란?

간단하게 말하자면, 데이터에 순차적으로 접근할 수 있는 객체인 iterator를 반환해주는 함수 입니다.

그렇다면 generator를 어떻게 활용할까요?

generator 활용법

제너레이터 활용법은 크게 두가지 입니다.

• yield 와 next()의 활용
• () 의 활용

1. yield와 next()를 활용한 코드

def func(l:list):
    for i in l:
        yield i +10


nums = func([1,2,3,4,5])

print(func(nums))   #<generator object func at 0x7fe75008f580>
print(next(nums))   #11
print(next(nums))   #12
print(next(nums))   #13
print(next(nums))   #14
print(next(nums))   #15

첫번째 print() 구문을 보시면 yield 구문을 활용하여 generator가 생성되신 것을 확인하실 수 있습니다.

def func(l:list):
    for i in l:
        yield i +10


nums = func([1,2,3,4,5])

print(func(nums))   #<generator object func at 0x7fe75008f580>

for i in nums:
    print(i)

위와 같이 반복문을 활용할 수도 있는데요. 결과는 위 코드와 같은 결과를 보입니다.

2. ()를 활용한 코드

nums = (i + 10 for i in range(1,6))

print(nums) # <generator object <genexpr> at 0x7fc340036190>

for i in nums:
    print(i)

이렇듯 구문을 ()로 감싸주게 되면 generator가 생성되는 것을 확인 하실 수 있습니다.

generator의 동작 방법은 알아보았습니다.

근데 이러한 동작 방법이 어떻게 메모리 효율성에 영향을 미치는 것일까요?

generator가 memory 효율성에 미치는 영향

Python 주로 데이터를 다룰 때 활용하는 언어입니다(데이터 수집, 인공지능 등). 데이터에서 유의미한 결과를 얻기 위해서는 정말 방대한 데이터를 활용할텐데요. 큰 양의 데이터를 한번에 담게 되면 메모리 부족 현상이 발생하여 프로그램이 갑자기 중단되는 등의 문제가 발생할 수 있습니다.

이때 generator는 개발자에게 엄청난 도움을 주게 됩니다.

generator는 모든 값의 순서를 기억한 상태로 동작하기 전까지 메모리를 할당하지 않기 때문입니다.

그렇기에 generator를 활용하게 되면 데이터를 한번에 적재하지 않아도 되기 때문에 메모리 소비를 줄일 수 있습니다. 즉, 한번에 적재하고 활용하는 방식 보다 훨씬 안정적인 방법이라고 할 수 있습니다.

또한 필요할 때 마다 호출하여 사용하는 지연 평가 방식이 가능하기 때문에 메모리를 효율적으로 사용할 수 있습니다.

C언어를 사용할 때는 malloc() 함수와 free()함수를 통해 메모리를 직접 할당/해제를 해주었습니다. 

그런데 Python을 사용할 때는 별도로 메모리를 관리하지 않더라구요.

문득 왜일까? 라는 생각이 들어서 알아보고 정리를 해보려고 합니다.

Python의 메모리 관리

파이썬은 Garbage Collector가 메모리를 관리해줍니다. C언어와 달리 사람이 메모리를 직접 할당/해제 하는 것이 아니라 언어 자체에서 직접 관리해주는 방식인데요. 

가장 많이 활용하는 방식은 Reference Counting 이라는 방식입니다.

Reference Counting 이란?

Reference Counting 방식이란, 객체를 얼마나 참조하는지를 통해 메모리를 관리하는 방식입니다.

Python은 객체를 생성하면 Heap 메모리에 객체를 생성하는데요. 

예를 들어, 다음과 같은 코드가 있을 때 s라는 변수가 객체를 참조하는 것을 counting 하여 메모리를 관리합니다.

s = 'hello world'

위와 같은 코드를 작성하면 다음과 같이 변수가 객체를 참조하게 됩니다.

'hello world'라는 객체를 s에 할당했을 때, Garbage Collector는 'hello world'라는 객체의 reference counting을 1 증가시키고 메모리에 할당합니다.

반대로 s라는 변수가 다른 객체를 참조하게 되었을 때는 reference counting이 0이 될 것이고 Garbage Collector는 이를 통해 메모리를 해제하게 됩니다.

직접 확인해보면 다음과 같습니다.

s가 호출된 함수가 종료되면 reference counting은 0이 되어 메모리는 해제되게 됩니다.

Garbage Collector의 장점 및 단점

사람이 직접 관리하지 않아도 메모리 관리가 되기 때문에 편하지만, 장점만 존재하는 것은 아닙니다.

Garbage Collector의 장점이라 함은 다음과 같습니다.

• reference counting이 0 이 될 때마다 메모리를 해제해주기 때문에 실시간 작업이 가능하다.
• 위와 같은 이유로 메모리 관리가 간편하며 즉시 메모리에서 해제가 가능하다.

반면 단점 또한 존재합니다.

• Object 마다 reference counting을 수행해주어야 하기 때문에 관리 비용이 많이 듭니다.
• Object의 reference count가 0이 될 경우, 연쇄적인 Garbage Collecting이 발생할 수 있습니다.
• 사람이 직접 할당/해제를 하지 않기 때문에 세밀한 메모리 관리가 어렵다.