이 글은 comp.lang.python에 있었던 줄토론으로서, 여기에 게시하여 필요할 때마다 읽어 보려고 한다 (상대적으로 자주 언급되는 질문 하나를 다룬다).
원하신다면 대신 구글에서 읽어 보시면 되겠다.
최근에 (이 글은 참조용으로 2002년 4월에 작성중이다), 지식을 찾아 온 한 검색자가 comp.lang.python에 다음과 같은 질의를 게시하였다:
여러분,
내가 파이썬을 아주 좋아하는 이유중 하나는 서술문이 예상대로 잘 작동한다는 것입니다.
예를 들어 사전에 dict.values()를 사용한다면:
dict.values()의 결과를 저장하고, 그 사전을 나중에 변경하더라도,
앞서 저장한 결과가 그대로이지요.
>>> dict = {'a':1,'b':2}
>>> list = dict.values()
>>> list
[1, 2]
>>> dict['a']=3
>>> list
[1, 2]
>>> dict
{'a': 3, 'b': 2}
그렇지만, 사전이 리스트를 값으로 가지고 있을 경우,
생각지 못한 행위를 하는 군요 (그 때문에 최근 코드가 망가진 경험이 있어요):
사전을 바꾸면, dict.values()로 앞서 만든 리스트도 자동으로 갱신됩니다.
좋은 특징이지만, 전혀 생각지 못했습니다!
>>> dict = {'a':[1],'b':[2]}
>>> list = dict.values()
>>> list
[[1], [2]]
>>> dict['a'].append(3)
>>> dict
{'a': [1, 3], 'b': [2]}
>>> list
[[1, 3], [2]]
언듯 보기에 첫 사례에서는 사본이 반환되는 반면,
두 번째 사례에서는 리스트 참조가 반환되는 것 같습니다.
좋습니다. 하지만 파이썬의 철학에 따르면 사전에서 리스트로 놀든 그 무엇이든
신경쓸 필요가 없어야 한다고 생각합니다.
사전에 넣어둔 값의 유형을 알아야 그 행위를 예측할 수 있다니,
약간 직관에 어긋나네요.
여기에서 누가 잘못인가요: 나의 직관입니까 아니면 파이썬 (2.2)입니까?
나의 직관이 문제라면, 어떻게 해야 파이썬의 실행모델에 관하여
나의 생각을 훈련시킬 수 있을까요, 나의 직관이 좀 나아질 수 있을까요 ;-)
말할 필요도 없이, 게시자의 직관이 잘못이다. 그러나 그 만이 이런 종류의 오해에 빠지는 것은 아니다.
다행스럽게도 그에게는 파이썬에 좀 더 정통한 게시자가 있었다 -- 본인과 알렉스 마르텔리(Alex Martelli)가 말이다 -- 그날 특히나 교훈을 주는 기분으로 , 나는 장문의 글을 써서 그가 실수한 방향과는 다른 방식들을 설명했다.
> 내가 파이썬을 아주 좋아하는 이유중 하나는
> 서술문이 예상대로 잘 작동한다는 것입니다.
물론, 파이썬은 나의 예상대로 잘 작동합니다.
그러나, 이정도로는 본인이나 파이썬에 관해서 설명이 부족하겠지요 <wink>.
이메일의 끝에서, 이렇게 말씀하셨습니다:
> 여기에서 누가 잘못인가요: 나의 직관입니까 아니면 파이썬 (2.2)입니까?
> 나의 직관이 문제라면, 어떻게 해야 파이썬의 실행모델에 관하여
> 나의 생각을 훈련시킬 수 있을까요, 나의 직관이 좀 나아질 수 있을까요 ;-)
당신이 잘못입니다 :) 지금은 이메일을 읽을 수 없기 때문에[1],
시간을 내어 당신에게 ascii 그림을 그려서 보여 드립니다.
먼저, 전문용어를 바로 씁시다. 실제로, 무엇보다도 용어에 오해가 있습니다.
"변수"라는 용어는 파이썬적인 문맥에서는 특히나 도움이 되지 못합니다.
나는 "이름"과 "바인딩" 그리고 "객체"라는 용어를 선호합니다.
이름은 다음과 같습니다:
,-----.
| foo |
`-----'
이름은 이름공간에 존재하지만, 지금 당장은 실제로는 중요하지 않습니다.
무대에 오른 이름공간 만이 인터프리터의 판독-평가-인쇄 회돌이에 연관되어 있습니다.
실제로 이름은 지금 드라마에서 작은 배역일 뿐입니다;
바인딩과 객체가 진짜 주인공입니다.
바인딩은 다음과 같이 생겼습니다:
------------>
바인딩의 왼쪽에는 이름이나 기타 "장소"가 붙습니다.
예를 들어 리스트나 사전의 엔트리 또는 객체의 속성 같은 것이 붙습니다.
오른쪽은 언제나 객체가 붙습니다[2].
객체는 다음과 같습니다:
+-------+
| "bar" |
+-------+
이것은 문자열 "bar"를 뜻합니다. 다른 유형의 객체는 다르게 그려지겠지만,
모쪼록 내가 뜻하는 바를 이해하시리라 믿습니다.
> 예를 들어 사전에 dict.values()를 사용하는 것처럼 말이지요:
> dict.values()의 결과를 저장하고, 그 사전을 나중에 변경하더라도,
> 앞서 저장한 결과가 그대로이지요.
>>>> dict = {'a':1,'b':2}
이 서술문 이후로는 이런 그림을 그리는게 적절할 듯 하군요:
,------. +-------+
| dict |------>|+-----+| +---+
`------' || "a" |+---->| 1 |
|+-----+| +---+
|+-----+| +---+
|| "b" |+---->| 2 |
|+-----+| +---+
+-------+
> >>> list = dict.values()
이제 다음은:
,------. +-------+
| dict |------>|+-----+| +---+
`------' || "a" |+------------>| 1 |
|+-----+| +---+
|+-----+| /\
|| "b" |+-----. ,---'
|+-----+| | |
+-------+ `----+----.
| |
,------. +-----+ | \/
| list |------>| [0]-+------------' +---+
`------' | [1]-+--------------->| 2 |
+-----+ +---+
> >>> list
> [1, 2]
물론, 놀랄 일은 아닙니다.
> >>> dict['a']=3
이제 이것은:
,------. +-------+
| dict |------>|+-----+| +---+
`------' || "a" |+-. | 1 |
|+-----+| | +---+
|+-----+| | /\
|| "b" |+-+---. ,---'
|+-----+| | | |
+-------+ | `----+----.
| | |
,------. +-----+ | | \/
| list |------>| [0]-+---+--------' +---+
`------' | [1]-+---+----------->| 2 |
+-----+ | +---+
| +---+
`----------->| 3 |
+---+
> >>> list
> [1, 2]
> >>> dict
> {'a': 3, 'b': 2}
이것도 역시 별로 놀랍지 않습니다;
그냥 위의 화살표(바인딩)을 따라가세요.
> 그렇지만, 사전이 리스트를 값으로 가지고 있을 경우,
> 생각지 못한 행위를 하는 군요 (그 때문에 최근 코드가 망가진 경험이 있어요):
> 사전을 바꾸면, dict.values()로 앞서 만든 리스트도 자동으로 갱신됩니다.
> 좋은 특징이지만, 전혀 생각지 못했습니다!
그것은 당신이 이름과 객체 그리고 바인딩이라는 관점에서
생각하고 있지 않기 때문입니다.
> >>> dict = {'a':[1],'b':[2]}
,------. +-------+
| dict |------>|+-----+| +-----+ +---+
`------' || "a" |+---->| [0]-+-->| 1 |
|+-----+| +-----+ +---+
|+-----+| +-----+ +---+
|| "b" |+---->| [0]-+-->| 2 |
|+-----+| +-----+ +---+
+-------+
> >>> list = dict.values()
,------. +-------+
| dict |------>|+-----+| +-----+ +---+
`------' || "a" |+------------>| [0]-+-->| 1 |
|+-----+| +-----+ +---+
|+-----+| /\
|| "b" |+-----. ,----'
|+-----+| | |
+-------+ `----+-----.
| |
,------. +-----+ | \/
| list |------>| [0]-+------------' +-----+ +---+
`------' | [1]-+--------------->| [0]-+-->| 2 |
+-----+ +-----+ +---+
> >>> list
> [[1], [2]]
역시, 여기서도 놀랄일이 아닙니다.
> >>> dict['a'].append(3)
+---+
,------. +-------+ ,->| 1 |
| dict |------>|+-----+| +-----+ | +---+
`------' || "a" |+------------>| [0]-+-'
|+-----+| | [1]-+-.
|+-----+| +-----+ | +---+
|| "b" |+-----. /\ `->| 3 |
|+-----+| | ,----' +---+
+-------+ | |
`----+-----.
,------. +-----+ | \/
| list |------>| [0]-+------------' +-----+ +---+
`------' | [1]-+--------------->| [0]-+-->| 2 |
+-----+ +-----+ +---+
> >>> dict
> {'a': [1, 3], 'b': [2]}
> >>> list
> [[1, 3], [2]]
이제 이것도 그렇게 놀랄일이 아닐 듯 싶습니다.
> 언듯 보기에 첫 사례에서는 사본이 반환되는 반면,
> 두 번째 사례에서는 리스트 참조가 반환되는 것 같습니다.
> 좋습니다. 하지만 파이썬의 철학에 따르면 사전에서 리스트로 놀든 그 무엇이든
> 신경쓸 필요가 없어야 한다고 생각합니다.
> 사전에 넣어둔 값의 유형을 알아야 그 행위를 예측할 수 있다니,
> 약간 직관에 어긋나네요.
위의 그림을 보고서 어디에서 오해가 비롯되었는지 인지하지 못하겠다면,
더 말해봐야 도움이 될지 모르겠습니다.
함내세요,
M.
[1] Does anyone know where the starship's gone?
[2] Anyone mentioning UnboundLocalError at this point will be shot.
--
A.D. 1517: Martin Luther nails his 95 Theses to the church door and
is promptly moderated down to (-1, Flamebait).
-- http://slashdot.org/comments.pl?sid=01/02/09/1815221&cid=52
(although I've seen it before)
게시하고 나서 얼마후에 이메일을 다시 사용할 수 있게 되었다. 그래서 나는 시간 낭비가 다시 일상이 되었다. 언젠가는 다이어그램을 dia 등등으로 다시 그리게 될지도 모르겠다 (아마도 이메일이 또다시 망가지면...).
> 여러분,
>
> 내가 파이썬을 아주 좋아하는 이유중 하나는 서술문이 예상대로 잘 작동한다는 것입니다.
> 예를 들어 사전에 dict.values()를 사용하는 것처럼 말이지요:
> dict.values()의 결과를 저장하고, 그 사전을 나중에 변경하더라도,
> 앞서 저장한 결과가 그대로이지요.
사전에서 .values() 메쏘드는 값들을 새로운 리스트로 돌려주도록 설계되어 있습니다.
그것은 어쨌거나 어쩔 수없는 일인데,
그 이유는 사전이 보통 그의 값들을 리스트로 보유하고 있지 않으며,
그래서 요청받을 때마다 바로바로 그 리스트를 구축해야 하기 때문입니다.
그것은 사본이 아닙니다 -- 새로운 리스트 객체이지요.
그렇지만, 파이썬은 일반적으로 사본을 만들어야 하는 특정한 상황을 제외하고 복사하지 않습니다.
.values() 메쏘드는 앞서 언급한 바와 같이...
기존에 있던 객체의 사본이 아니라, 새로운 객체입니다..
일반적으로, 가능하면 파이썬은 이미 있는 것이면
같은 객체에 대하여 복사하기 보다는 참조를 돌려줍니다;
정말로 사본을 원한다고 요청하려면 -- copy 모듈을 보세요.
물론, 새로운 객체를 구축하는 일은 다른 사례입니다.
이것이 직관적이지 못하더라도, 그냥 인정합시다 --
엄청난 부담을 부과하지 않는 한 일반적으로는 대안이 없습니다.
뭐든지 "상황에 딱 맞게" 사본을 만들 수는 없는 일입니다.
명시적으로 요구할 때에만 사본을 얻는 것이 더 좋습니다
(그리고, 사본이든 참조이든 기존의 객체가 없다면 새로운 객체를 돌려주면 됩니다).
물론, 중간-단계의 사례가 있습니다 -- 조각썰기가 그 예입니다.
표준 연속열들은 조각썰기를 요청하면 새로운 객체를 돌려줍니다;
이것은 오직 리스트에만 적용됩니다
(변경불능 객체라면 복사를 하든 뭘 하든 신경쓸 필요가 없습니다).
리스트는 "자신의 일부를 공유할 수 없습니다".
그래서 조각썰기를 요청하면 사본을, 즉 새로운 리스트를 돌려줍니다
(물론, 일반적으로 thelist[:]와 같이 조각을 통채로 요청하면 새로운 리스트를 돌려주는데 --
그래서 그런 특별한 경우 반환된 그 새로운 객체는 기존의 객체의 사본처럼 보일 수 있습니다).
반면에, 유명한 Numeric 꾸러미에서 정의되는 배열 유형은 여러 배열 객체 사이에
데이터 모두 또는 일부를 공유할 수 있습니다. --
그래서 Numeric 배열의 조각은 원래 조각썰기 전의 자신의 배열과 공유됩니다.
그것은 새로운 객체랍니다. 명심하세요:
>>> import Numeric
>>> a=Numeric.array(range(6))
>>> b=a[:]
>>> id(a)
136052568
>>> id(b)
136052728
>>>
그러나 두 개의 다른 객체 a와 b는 데이터를 공유합니다:
>>> a
array([0, 1, 2, 3, 4, 5])
>>> b
array([0, 1, 2, 3, 4, 5])
>>> a[3]=23
>>> b
array([ 0, 1, 2, 23, 4, 5])
>>>
각 행위는 뒤에 훌륭한 실용적인 정신이 있습니다 --
리스트는 데이터 공유에 관하여 걱정할 필요가 없는 더할 나위 없이
단순한 방식이며, 배열은 지금까지와는 사용 사례가 다릅니다 --
그러나 두가지 비슷한 객체가 상세하게는 다르다는 사실에 놀라지 않기는 힘듭니다.
그러나 리스트 조각썰기 등등의 특별한 경우에 "우연히 일어나는" 모든 복사는
(나중에 더 설명한 한가지는 제외하고) 어떤 것이든 언제나 얕은 복사입니다.
특별히 deepcopy 모듈을 사용하라고 여러분이 요구하지 않는 한 --
파이썬은 _깊은_ 복사라는 무거운 짐을 짊어지지 않습니다.
깊은 복사는 과중한 부담입니다. --
deepcopy 함수는 회돌이를 감시하면서 참조점들의 신분을 다시 만들고,
잠재적으로 얼마든지 깊이 재귀적으로 따라 들어갑니다 --
서로를 참조하는 객체들의 그래프를 그 복잡도에 상관없이 믿음직하게 재구성해야 합니다.
그래서 잘 작동한다고 할지라도, 일상적으로 행하는 얕은 복사만큼의 속도는 당연히 따라올 수 없습니다
(얕은 복사마저도 기존의 객체에 그냥 참조점을 넘기는 만큼의 속도만큼 빠를 수는 없습니다).
그래서, 당신은 여기에서 함정에 빠진 것 같습니다:
> 그렇지만, 사전이 리스트를 값으로 가지고 있을 경우,
> 생각지 못한 행위를 하는 군요 (그 때문에 최근 코드가 망가진 경험이 있어요):
> 사전을 바꾸면, dict.values()로 앞서 만든 리스트도 자동으로 갱신됩니다.
> 좋은 특징이지만, 전혀 생각지 못했습니다!
실제로는 그렇지 않습니다 -- (사전 그 자체를 바꾸는 것이 아니라) 사전이 가리키는 _objects를 바꾸더라도,
똑같이-같은-객체를 가리키는 다른 참조점들은 여전히 똑 같은 객체를 가리킵니다 --
그 객체들이 수정되면, 어떤 방식으로 참조하더라도 그 수정된 객체들이 보입니다.
>>>> dict = {'a':[1],'b':[2]}
>>>> list = dict.values()
>>>> list
> [[1], [2]]
내장 유형의 이름을 변수로 사용하지 마세요:
이렇게 하다가는 언젠가는 혼이 날 것입니다.
dict, list, str, tuple, file, int, long, float, unicode... 등등
매력적으로 보일지라도 이런 식별자를 의도적으로 사용하지 마세요
(분명, "매력적인 함정(attractive nuisance)"입니다).
그런 습관을 버리지 않는다면, 언젠가는 x=list('ciao')로 리스트를 구축하다가
에러를 맞이하고 당황하게 될 것입니다...
식별자인 'list'를 리스트 유형 그 자체가 아니라
어떤 리스트 객체를 가리키도록 다시 묶었기 때문입니다.
alist, somedict, myfile, 기타 등등...
여기에서의 문제와 관련되지는 않지만, 그냥 노파심에서 한 마디합니다!-)
>>>> dict['a'].append(3)
이렇게 하더라도 "사전은 바뀌지 않습니다" -- 사전 객체에는 여전히 똑 같은 참조점이 담겨 있습니다.
같은 아이디를 가진 객체를 가리킵니다 (두개의 문자열 객체와 키 그리고 두 개의 리스트 객체와 값).
두 객체중의 하나를 수정하고 있지만, 그것은 아주 다른 문제입니다. 앞서 언급한 리스트 객체는 그것을
가리키는 어떤 참조점으로도 변경할 수 있습니다. 예를 들면:
>>> alist=list('ciao')
>>> adict={'a':alist}
>>> adict
{'a': ['c', 'i', 'a', 'o']}
>>> alist.pop()
'o'
>>> adict
{'a': ['c', 'i', 'a']}
>>>
사전 adict가 alist 내용의 사본을 가리키기를 원한다면 (원하신다면 "그대로 찍어서(snapshot)"),
다음과 같이 기술할 수 있습니다:
>>> import copy
>>> alist=list('ciao')
>>> adict={'a':copy.copy(alist)}
>>> adict
{'a': ['c', 'i', 'a', 'o']}
>>> alist.pop()
'o'
>>> adict
{'a': ['c', 'i', 'a', 'o']}
>>>
그러면 사전 객체의 문자열-표현은 alist가 가리키는 이름의 리스트에 어떤 변화를 주어도 영향을 받지 않습니다.
그 사전 객체의 문자열 표현은 사전 객체가 가리키는 객체들에게 자신의 임무를 나누어줍니다.
그래서, 그것을 분리하고 싶다면, 복사할 필요가 있습니다 -- 아마도 깊은 복사겠지요.
사실 (<shudder>... 아 아닙니다. 실제로 그럴필요 까지는 없지만,...:-).
>>>> dict
> {'a': [1, 3], 'b': [2]}
>>>> list
> [[1, 3], [2]]
>
> 언듯 보기에 첫 사례에서는 사본이 반환되는 반면,
> 두 번째 사례에서는 리스트 참조가 반환되는 것 같습니다.
아닙니다. 언제나 참조로 건넵니다. .values()는 기존의 객체에 참조점을 돌려주지 않으며
기존 객체의 사본을 돌려주지도 않습니다. 왜냐하면 이 경우에 "기존의 객체"가 없기 때문입니다 --
그래서 구축된 규격에 맞게 언제나 새로운 객체를 돌려줍니다.
> 파이썬의 철학에 따르면 사전에서 리스트로 놀든 그 무엇이든
> 신경쓸 필요가 없어야 한다고 생각합니다.
> 사전에 넣어둔 값의 유형을 알아야 그 행위를 예측할 수 있다니,
> 약간 직관에 어긋나네요.
그런 의존성은 없습니다. 단지 큰 차이가 있다면
한 객체를 변경하는 것과 그 객체가 가리키는 다른 객체를 변경하는 것 사이에 있습니다.
100년전 볼로냐(Bologna)에는 지역 영웅의 조각상이 서 있었습니다.
손가락으로 무언가를 가리키면서 말입니다 -- 생각건대 미래를
가리키는 것이었겠지만, 정확하게 손가락이 가리키는 곳을 보고서,
사람들은 곧 그것을 "벨포아(Belfiore) 호텔을 가리키는 조각상"이라고 인식하였습니다.
어느날엔가 한 기업가가 그 호텔을 사서 다시 지었습니다 -- 특히,
호텔이 있던 곳은 이제 레스토랑 다 카를로(Da Carlo)가 되었습니다.
그래서, "벨포아 호텔을 가리키던 조각상"은 갑자기
"다카를로 레스토랑을 가리키는 조각상"이 되어 버렸습니다...!
놀랍지 않나요? 대리석이 녹아 내렸을리도 없고 그 조각상이 이사를 가거나 철거된 것도 아닐텐데...?
이건 실제 있었던 이야기입니다. 어쨌든 (관련된 호텔 이름이나 레스토랑 이름은 확실하지 않지만 말입니다
-- 그에 관해서는 잘 모르겠네요), 그러나 여기에서 이해에 도움이 되리라 생각합니다.
사전, 즉 조각상은 전혀 변하지 않았습니다.
그 조각상이 가리키는 객체들이 인지하지 못하는 사이에 변해 버렸다면 몰라도 말입니다.
사람들이 알고 있는 그 이름(사전의 문자열-표현)은 바뀔 수 있습니다.
그 이름(표현)은 본질적이지 않고 항구성이 없는,
조각상(사전)의 "우연적" 특징을 가리키고 있었습니다.
> 여기에서 누가 잘못인가요: 나의 직관입니까 아니면 파이썬 (2.2)입니까?
> 나의 직관이 문제라면, 어떻게 해야 파이썬의 실행모델에 관하여
> 나의 생각을 훈련시킬 수 있을까요, 나의 직관이 좀 나아질 수 있을까요 ;-)
(파이썬은 당연히 할 일을 했을 뿐) 여기에서 길을 잃은 당신의 직관은 여러가지 방식으로 훈련할 수 있습니다.
픽션을 좋아하신다면, J. L. Borges 그리고 I. Calvino의 작품이 한 번 도전해 볼 만 합니다.
상당히 복잡하지만 그 만큼 더 재미있습니다.
철학자의 오류를 날려버리기 위해 고군분투하는 공학자들의 논-픽션을 좋아한다면,
비트겐스타인(Wittgenstein)과 콜집스키(Korzibsky)가 훌륭합니다.
진심입니다. 그러나 많은 파이써니스타가 이런 문제에는 실제로 신경쓰지 않고 있습니다.
어쨌든, 이 그룹과 문서고 GvR과 /F의 수필 그리고 파이썬 소스도 흥미로운 읽을 거리입니다.
알렉스(Alex)
알렉스(Alex)가 언급한 /F의 수필이란 아마도 이 글을 말하는 것일게다 (뭐 그렇지 않다고 하더라도, 여전히 읽을 가치가 있다). 같은 문제를 더 간결한 문체로 다룬다.
이 모든 것이 이해가 되었음을 보여주기 위해, 그 게시자는 만족의 인사를 남기고 떠났다:
경애하옵는 마이크(Michael), 존경하는 알렉스(Alex), 여러분은 훌륭한 스승이십니다!!! 마이클(Michael), 당신이 그려준 그림에서 요점을 이해하는데 정말로 큰 도움을 받았습니다. 당신이 그려준 그림 정말 고맙습니다! 알렉스(Alex), 벨포아 호텔을 가리키는 조각상에 관한 일화를 듣고 내 직관이 틀렸음을 확실하게 깨닫았습니다! 앞으로도 정말 잊을 수 없을 것 같습니다! 답해 주셔서 고맙습니다! 오늘 많은 걸 배우고, 진짜로 파이썬 매니아가 되어 가고 있습니다!
모쪼록 이 답변들이 여러분에게도 도움이 되시기를 바란다.
자, 그는 운좋게도 나를 사로잡았다. 그런 기분이 들도록 말이다. 알렉스(Alex)는 항상 이런 종류의 글을 쓴다.
XHTML 평가 CSS 평가 논평과 칭찬 그리고 지적 등등은 mwh@python.net로 이메일을 보내주시기를 바란다.이 문서를 번역하고 싶다면, 절대적으로 자유롭다. 번역한 곳을 링크로 알려 주시면 고맙겠다. 지금까지 내가 알고 있는 링크는 다음과 같다