파이썬 문서는 매개 변수가 참조 또는 값으로 전달되는지에 대해 명확하지 않은 것으로 보이며 다음 코드는 변경되지 않은 값 'Original'을 생성합니다.

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change(self.variable)
        print(self.variable)

    def change(self, var):
        var = 'Changed'

실제 참조로 변수를 전달하기 위해 할 수있는 일이 있습니까?

인수는 할당에 의해 전달됩니다 . 이것의 근거는 두 가지입니다.

1. 전달 된 파라미터는 사실이다 기준 개체에 (그러나, 기준이되는 값으로 전달)
2. 일부 데이터 유형은 변경 가능하지만 다른 유형은 변경 불가능

그래서:

• 당신이 전달하는 경우 변경 가능한 방법으로 개체를, 방법은 같은 객체에 대한 참조를 가져옵니다 당신은 당신의 마음의 기쁨으로 변이 할 수 있지만,이 방법에 대한 참조를 바인딩하는 경우, 외부 범위는 후에 그것에 대해 아무것도 몰라, 것 완료되었으므로 외부 참조는 여전히 원래 객체를 가리 킵니다.

• 당신이 전달하는 경우 불변 하는 방법에 오브젝트를, 당신은 여전히 외부 참조를 바인딩 할 수없고 심지어 개체를 변이 수 없습니다.

더 명확하게하기 위해 몇 가지 예를 들어 보겠습니다.

리스트-가변 타입

메소드에 전달 된 목록을 수정 해 봅시다 :

def try_to_change_list_contents(the_list):
    print('got', the_list)
    the_list.append('four')
    print('changed to', the_list)

outer_list = ['one', 'two', 'three']

print('before, outer_list =', outer_list)
try_to_change_list_contents(outer_list)
print('after, outer_list =', outer_list)

산출:

before, outer_list = ['one', 'two', 'three']
got ['one', 'two', 'three']
changed to ['one', 'two', 'three', 'four']
after, outer_list = ['one', 'two', 'three', 'four']

전달 된 매개 변수 outer_list는 복사본이 아닌에 대한 참조 이므로 변경 목록 메소드를 사용하여 변경하고 외부 범위에 변경 사항을 반영 할 수 있습니다.

이제 매개 변수로 전달 된 참조를 변경하려고 할 때 어떤 일이 발생하는지 봅시다 :

def try_to_change_list_reference(the_list):
    print('got', the_list)
    the_list = ['and', 'we', 'can', 'not', 'lie']
    print('set to', the_list)

outer_list = ['we', 'like', 'proper', 'English']

print('before, outer_list =', outer_list)
try_to_change_list_reference(outer_list)
print('after, outer_list =', outer_list)

산출:

before, outer_list = ['we', 'like', 'proper', 'English']
got ['we', 'like', 'proper', 'English']
set to ['and', 'we', 'can', 'not', 'lie']
after, outer_list = ['we', 'like', 'proper', 'English']

때문에 the_list매개 변수가 그것에 새 목록을 할당 값에 의해 전달 된 방법 이외의 코드를 볼 수 있다는 아무런 영향을 미치지 않습니다. 는 the_list의 복사본이었다 outer_list참조, 우리는 한 the_list새 목록에 지점을하지만, 변경할 수있는 방법이 없었다 outer_list뾰족한는.

문자열-불변의 타입

불변이므로 문자열의 내용을 변경하기 위해 할 수있는 일은 없습니다

이제 참조를 변경해 봅시다

def try_to_change_string_reference(the_string):
    print('got', the_string)
    the_string = 'In a kingdom by the sea'
    print('set to', the_string)

outer_string = 'It was many and many a year ago'

print('before, outer_string =', outer_string)
try_to_change_string_reference(outer_string)
print('after, outer_string =', outer_string)

산출:

before, outer_string = It was many and many a year ago
got It was many and many a year ago
set to In a kingdom by the sea
after, outer_string = It was many and many a year ago

다시 말하지만 the_string매개 변수가 값으로 전달되었으므로 새 문자열을 할당하면 메서드 외부의 코드에서 볼 수 없었습니다. 는 the_string의 복사본이었다 outer_string참조, 우리는 한 the_string새로운 문자열로 포인트를하지만, 변경할 수있는 방법이 없었다 outer_string뾰족한는.

나는 이것이 약간의 정리를 바랍니다.

편집 : 이것은 @David가 처음에 "실제 참조로 변수를 전달하기 위해 할 수있는 일이 있습니까?"라는 질문에 대답하지는 않습니다. 그 작업을 해보자.

우리는 어떻게이 문제를 해결합니까?

@Andrea의 답변에서 알 수 있듯이 새로운 값을 반환 할 수 있습니다. 이것은 물건이 전달되는 방식을 바꾸지는 않지만 원하는 정보를 다시 얻을 수있게합니다.

def return_a_whole_new_string(the_string):
    new_string = something_to_do_with_the_old_string(the_string)
    return new_string

# then you could call it like
my_string = return_a_whole_new_string(my_string)

반환 값을 사용하지 않으려면 값을 보유하고 함수에 전달하거나 목록과 같은 기존 클래스를 사용하는 클래스를 만들 수 있습니다.

def use_a_wrapper_to_simulate_pass_by_reference(stuff_to_change):
    new_string = something_to_do_with_the_old_string(stuff_to_change[0])
    stuff_to_change[0] = new_string

# then you could call it like
wrapper = [my_string]
use_a_wrapper_to_simulate_pass_by_reference(wrapper)

do_something_with(wrapper[0])

비록 약간 성가신 것 같습니다.

파이썬에서 변수가 무엇인지에 대한 오해에서 문제가 발생합니다. 대부분의 전통적인 언어에 익숙하다면 다음 순서로 일어나는 일에 대한 정신적 모델이 있습니다.

a = 1
a = 2

a그 값을 저장하는 메모리 위치 라고 생각 하고 값 1을 저장하도록 업데이트됩니다 2. 그것이 파이썬에서 일하는 방식이 아닙니다. 오히려 a값이있는 객체에 대한 참조로 1시작한 다음 값 이있는 객체에 대한 참조로 다시 할당됩니다 2. 이 두 개체는 a더 이상 첫 번째 개체를 참조하지 않더라도 계속 공존 할 수 있습니다 . 실제로 그것들은 프로그램 내에서 다른 많은 참조에 의해 공유 될 수 있습니다.

매개 변수를 사용하여 함수를 호출하면 전달 된 객체를 참조하는 새 참조가 작성됩니다. 이는 함수 호출에 사용 된 참조와 별개이므로 해당 참조를 업데이트하여 참조를 참조 할 수있는 방법이 없습니다. 새로운 객체. 귀하의 예에서 :

def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'

self.variable문자열 객체에 대한 참조 'Original'입니다. 호출 Change하면 var객체에 대한 두 번째 참조 를 만듭니다. 함수 내에서 var다른 문자열 객체에 대한 참조 를 다시 할당 'Changed'하지만 참조 self.variable는 분리되어 있으며 변경되지 않습니다.

이를 해결하는 유일한 방법은 변경 가능한 객체를 전달하는 것입니다. 두 참조 모두 동일한 객체를 참조하므로 객체에 대한 모든 변경 사항이 두 곳에 모두 반영됩니다.

def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

다른 답변은 다소 길고 복잡하다는 것을 알았 으므로이 간단한 다이어그램을 작성하여 Python이 변수 및 매개 변수를 처리하는 방식을 설명했습니다.

값으로 전달 또는 참조로 전달되지 않으며 개체 별 호출입니다. Fredrik Lundh의 이것을보십시오 :

http://effbot.org/zone/call-by-object.htm

중요한 인용문은 다음과 같습니다.

"... 변수 [이름]은 객체 가 아닙니다 . 다른 변수로 표시하거나 객체가 참조 할 수 없습니다."

예를 들어, Change메소드가 호출되면 네임 스페이스 가 작성됩니다. 및 var문자열 객체에 대해, 해당 네임 스페이스 내에서 이름이됩니다 'Original'. 그런 다음 해당 개체는 두 개의 네임 스페이스에 이름을 갖습니다. 그런 다음 새 문자열 객체에 var = 'Changed'바인딩 var하므로 메서드의 네임 스페이스가 잊어 버립니다 'Original'. 마지막으로, 그 네임 스페이스는 잊혀지고 문자열도 'Changed'함께 잊어 버립니다 .

참조 / 가치 대신 할당 으로 전달 되는 것을 생각하십시오 . 그렇게하면 정규 과제 동안 어떤 일이 발생하는지 이해하는 한 항상 명확합니다.

따라서리스트를 함수 / 메소드에 전달할 때리스트는 매개 변수 이름에 할당됩니다. 목록에 추가하면 목록이 수정됩니다. 함수 내 에서 목록을 다시 할당하면 다음과 같은 이유로 원래 목록이 변경되지 않습니다.

a = [1, 2, 3]
b = a
b.append(4)
b = ['a', 'b']
print a, b      # prints [1, 2, 3, 4] ['a', 'b']

불변 유형은 수정할 수 없으므로 값으로 전달되는 것처럼 보입니다 . int를 함수에 전달하면 int를 함수의 매개 변수에 할당하는 것을 의미합니다. 다시 할당 할 수는 있지만 원래 변수 값은 변경되지 않습니다.

Effbot (일명 Fredrik Lundh)은 Python의 변수 전달 스타일을 객체 별 호출로 설명했습니다. http://effbot.org/zone/call-by-object.htm

객체는 힙에 할당되며 포인터는 어디에서나 전달 될 수 있습니다.

• 과 같은 할당을 수행 x = 1000하면 현재 네임 스페이스의 "x"문자열을 1000을 포함하는 정수 객체에 대한 포인터에 매핑하는 사전 항목이 생성됩니다.

• 로 "x"를 업데이트 x = 2000하면 새 정수 객체가 만들어지고 새 객체를 가리 키도록 사전이 업데이트됩니다. 오래 된 천 개체는 변경되지 않습니다 (그리고 다른 것이 개체를 참조하는지 여부에 따라 살아 있거나 없을 수 있습니다).

• 와 같은 새 할당을 수행하면 y = x"x"에 대한 항목과 동일한 객체를 가리키는 새 사전 항목 "y"가 생성됩니다.

• 문자열 및 정수와 같은 객체는 변경할 수 없습니다 . 이것은 객체가 생성 된 후에 객체를 변경할 수있는 메소드가 없음을 의미합니다. 예를 들어, 정수 객체가 천 번 생성되면 절대 변경되지 않습니다. 수학은 새로운 정수 객체를 생성하여 수행됩니다.

• 리스트와 같은 객체는 변경 가능 합니다. 이것은 객체의 내용이 객체를 가리키는 것으로 변경 될 수 있음을 의미합니다. 예를 들어 x = []; y = x; x.append(10); print y인쇄 [10]합니다. 빈 목록이 작성되었습니다. "x"와 "y"는 모두 동일한 목록을 가리 킵니다. APPEND의 방법 (데이터베이스에 레코드를 추가하는 등의) 변이 (업데이트) 목록 객체와 결과가 모두 "X"와 "Y"를 볼 수는 (단지 데이터베이스 업데이트로 해당 데이터베이스에 대한 모든 연결을 볼 것).

그것이 당신을 위해 문제를 분명히하기를 바랍니다.

기술적으로 파이썬은 항상 pass by reference values를 사용합니다 . 본인의 진술을 뒷받침하기 위해 다른 답변 을 반복하겠습니다 .

파이썬은 항상 참조로 전달 값을 사용합니다. 예외는 없습니다. 모든 변수 할당은 참조 값을 복사하는 것을 의미합니다. 예외 없음. 모든 변수는 참조 값에 바인딩 된 이름입니다. 항상.

참조 값을 대상 개체의 주소로 생각할 수 있습니다. 주소는 사용될 때 자동으로 역 참조됩니다. 이런 식으로 참조 값으로 작업하면 대상 객체로 직접 작업하는 것처럼 보입니다. 그러나 목표를 향해 한 걸음 더 나아가는 것 사이에는 항상 참조가 있습니다.

다음은 파이썬이 참조로 전달을 사용한다는 것을 증명하는 예입니다.

인수가 값으로 전달되면 외부를 lst수정할 수 없습니다. 녹색은 대상 객체이며 (검정은 내부에 저장된 값, 빨간색은 객체 유형), 노란색은 참조 값이 내부에있는 메모리이며 화살표로 표시됩니다. 파란색 실선 화살표는 점선 파선 화살표 경로를 통해 함수에 전달 된 참조 값입니다. 못생긴 짙은 노란색은 내부 사전입니다. (실제로 녹색 타원으로 그릴 수도 있습니다. 색상과 모양은 내부라고 말합니다.)

id()내장 함수를 사용하여 참조 값이 무엇인지 (즉, 대상 객체의 주소)를 알 수 있습니다.

컴파일 된 언어에서 변수는 유형의 값을 캡처 할 수있는 메모리 공간입니다. Python에서 변수는 대상 객체에 대한 참조 값을 보유하는 참조 변수에 바인딩 된 이름 (내부적으로 문자열로 캡처 됨)입니다. 변수의 이름은 내부 사전의 키이며 해당 사전 항목의 값 부분은 참조 값을 대상에 저장합니다.

파이썬에서는 참조 값이 숨겨져 있습니다. 참조 값을 저장하기위한 명시적인 사용자 유형이 없습니다. 그러나 모든 컨테이너가 요소를 대상 객체에 대한 참조로도 저장하기 때문에 목록 요소 (또는 다른 적합한 컨테이너 유형의 요소)를 참조 변수로 사용할 수 있습니다. 즉, 요소는 실제로 컨테이너 안에 포함되지 않으며 요소에 대한 참조 만 있습니다.

파이썬에는 변수가 없습니다

매개 변수 전달을 이해하는 열쇠는 "변수"에 대한 생각을 멈추는 것입니다. 파이썬에는 이름과 객체가 있으며 함께 변수처럼 보이지만 항상 세 가지를 구별하는 것이 유용합니다.

1. 파이썬에는 이름과 객체가 있습니다.
2. 할당은 이름을 객체에 바인딩합니다.
3. 함수에 인수를 전달하면 이름 (함수의 매개 변수 이름)도 객체에 바인딩됩니다.

그것이 전부입니다. 돌연변이는이 질문과 관련이 없습니다.

예:

a = 1

이것은 이름 a을 값 1을 보유한 정수 유형의 오브젝트에 바인드합니다 .

b = x

이 이름 바인딩 b이름이 것과 같은 객체에 x현재에 바인딩됩니다. 나중에 이름 b은 x더 이상 이름과 관련이 없습니다.

Python 3 언어 참조의 3.1 및 4.2 단원을 참조하십시오 .

질문에서 예를 읽는 방법

질문에 표시된 코드 self.Change(self.variable)에서이 명령문 은 이름 var(함수 범위 Change)을 값을 보유하는 객체 에 바인딩하고 'Original'할당 var = 'Changed'(함수 본문 Change)은 동일한 이름을 다시 지정합니다. 문자열을 잡아야하지만 완전히 다른 것이 될 수 있습니다).

참조로 전달하는 방법

따라서 변경하려는 것이 변경 가능한 객체이면 모든 것이 효과적으로 참조로 전달되므로 문제가 없습니다.

그것이 경우 불변의 객체 (예를 들어, 부울, 숫자, 문자열), 이동하는 방법은 변경 가능한 객체를 래핑하는 것입니다.
이것에 대한 빠르고 더러운 솔루션은 하나의 요소 목록입니다 ( self.variablepass 대신 [self.variable]함수 modify var[0]).
더 pythonic 접근법은 사소한 하나의 속성 클래스를 도입하는 것입니다. 이 함수는 클래스의 인스턴스를 수신하고 속성을 조작합니다.

내가 일반적으로 사용하는 간단한 트릭은 목록으로 감싸는 것입니다.

def Change(self, var):
    var[0] = 'Changed'

variable = ['Original']
self.Change(variable)      
print variable[0]

(예, 이것이 불편할 수 있음을 알고 있지만 때로는 그렇게하기에 충분히 간단합니다.)

(편집-블레어는 그의 정확한 답변을 업데이트하여 이제는 정확 해졌습니다)

블레어 콘래드 (Blair Conrad)에 의해 가장 많은 표를 얻은 현재 게시물은 그 결과와 관련하여 정확하지만 오해의 소지가 있으며 그 정의에 따라 경계선이 잘못되었다는 점에 주목해야합니다. 사용자가 참조로 전달하거나 값으로 전달할 수있는 많은 언어 (C와 같은)가 있지만 Python은 그중 하나가 아닙니다.

David Cournapeau의 답변은 실제 답변을 가리키며 Blair Conrad의 게시물의 동작이 왜 정확하지 않은지 설명합니다.

파이썬이 값으로 전달되는 한, 일부 데이터 ( "값"또는 "참조")가 전송되어야하기 때문에 모든 언어는 값으로 전달됩니다. 그러나 이것이 C 프로그래머가 그것을 생각한다는 의미에서 파이썬이 가치를 지니고 있다는 것을 의미하지는 않습니다.

당신이 행동을 원한다면 Blair Conrad의 대답은 괜찮습니다. 그러나 파이썬이 가치를 지니지 않거나 참조로 전달되지 않는 이유의 요점을 알고 싶다면 David Cournapeau의 대답을 읽으십시오.

여기에 정말 좋은 답변이 있습니다.

x = [ 2, 4, 4, 5, 5 ]
print x  # 2, 4, 4, 5, 5

def go( li ) :
  li = [ 5, 6, 7, 8 ]  # re-assigning what li POINTS TO, does not
  # change the value of the ORIGINAL variable x

go( x ) 
print x  # 2, 4, 4, 5, 5  [ STILL! ]


raw_input( 'press any key to continue' )

이 경우 var메서드에서 제목 Change이 지정된 변수 에에 대한 참조가 할당 self.variable되고 즉시 문자열을에 할당합니다 var. 더 이상 가리 키지 않습니다 self.variable. 다음 코드 스 니펫은 varand가 가리키는 데이터 구조 ( self.variable이 경우 목록) 를 수정하면 어떻게되는지 보여줍니다 .

>>> class PassByReference:
...     def __init__(self):
...         self.variable = ['Original']
...         self.change(self.variable)
...         print self.variable
...         
...     def change(self, var):
...         var.append('Changed')
... 
>>> q = PassByReference()
['Original', 'Changed']
>>> 

다른 사람이 이것을 더 명확히 할 수 있다고 확신합니다.

파이썬의 할당 별 체계는 C ++의 참조 매개 변수 옵션과 완전히 동일하지 않지만 실제로는 C 언어 (및 기타)의 인수 전달 모델과 매우 유사합니다.

• 불변 인수는 효과적으로 " 가치 별 " 으로 전달 됩니다 . 정수 및 문자열과 같은 객체는 복사하는 대신 객체 참조로 전달되지만 변경 불가능한 객체를 변경할 수 없기 때문에 결과는 복사하는 것과 매우 유사합니다.
• 가변 인수는 효과적으로 " 포인터로 "전달 됩니다 . 목록 및 사전과 같은 객체도 객체 참조를 통해 전달되는데, 이는 C가 포인터를 배열로 전달하는 방식과 유사합니다. C 객체와 같이 변경 가능한 객체는 함수에서 대신 변경 될 수 있습니다.

알 수 있듯이 변경 가능한 객체가 필요하지만 전역 변수가 도움이 될 수도 있고 이런 종류의 문제를 해결할 수도 있으므로 전역 변수를 확인하는 것이 좋습니다.

http://docs.python.org/3/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

예:

>>> def x(y):
...     global z
...     z = y
...

>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'z' is not defined

>>> x(2)
>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
2

여기에 대한 답변에 대한 많은 통찰력이 있지만 여기에 추가 요점이 명확하게 언급되어 있지 않다고 생각합니다. 파이썬 문서에서 인용 https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

"Python에서 함수 내에서만 참조되는 변수는 암시 적으로 전역 적입니다. 변수가 함수 본문의 어느 곳에 나 새로운 값이 할당되면 로컬로 간주됩니다. 변수에 함수 내에 새로운 값이 할당되면, 변수는 암시 적으로 지역적이며 명시 적으로 '글로벌'로 선언해야합니다. 처음에는 조금 놀랍지 만, 고려할 사항은 다음과 같습니다. 할당 된 변수에 전역을 요구하면 의도하지 않은 부작용에 대비할 수 있습니다. 반면에 모든 전역 참조에 전역이 필요한 경우 항상 전역을 사용하게되며 내장 함수 또는 가져온 모듈의 구성 요소에 대한 모든 참조를 전역으로 선언해야합니다. 부작용을 식별하기위한 글로벌 선언의 유용성을 무너 뜨릴 것입니다. "

가변 객체를 함수에 전달할 때도 여전히 적용됩니다. 그리고 객체에 할당하는 것과 함수의 객체에서 작동하는 것 사이의 행동 차이가 나는 이유를 분명히 설명합니다.

def test(l):
    print "Received", l , id(l)
    l = [0, 0, 0]
    print "Changed to", l, id(l)  # New local object created, breaking link to global l

l= [1,2,3]
print "Original", l, id(l)
test(l)
print "After", l, id(l)

제공합니다 :

Original [1, 2, 3] 4454645632
Received [1, 2, 3] 4454645632
Changed to [0, 0, 0] 4474591928
After [1, 2, 3] 4454645632

따라서 전역으로 선언되지 않은 전역 변수에 할당하면 새 로컬 객체가 만들어지고 원래 객체에 대한 링크가 끊어집니다.

다음은 pass by object파이썬에서 사용되는 개념에 대한 간단한 설명입니다 .
객체를 함수에 전달할 때마다 객체 자체가 전달됩니다 (파이썬의 객체는 실제로 다른 프로그래밍 언어에서 값을 호출하는 것입니다).이 객체에 대한 참조는 아닙니다. 다시 말해, 전화 할 때 :

def change_me(list):
   list = [1, 2, 3]

my_list = [0, 1]
change_me(my_list)

실제 객체-[0, 1] (다른 프로그래밍 언어에서는 값이라고 함)이 전달되고 있습니다. 실제로 함수 change_me는 다음과 같은 작업을 시도합니다.

[0, 1] = [1, 2, 3]

분명히 함수에 전달 된 객체는 변경되지 않습니다. 함수가 다음과 같은 경우 :

def change_me(list):
   list.append(2)

그런 다음 전화 결과는 다음과 같습니다.

[0, 1].append(2)

분명히 개체가 변경됩니다. 이 답변이 잘 설명되어 있습니다.

파이썬 에서이 기능이 어떻게 작동하는지에 대한 모든 훌륭한 설명 외에도 문제에 대한 간단한 제안은 보이지 않습니다. 객체와 인스턴스를 만드는 것처럼 보이는 것처럼 인스턴스 변수를 처리하고 변경하는 pythonic 방법은 다음과 같습니다.

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.Change()
        print self.variable

    def Change(self):
        self.variable = 'Changed'

인스턴스 메소드에서는 일반적으로 self인스턴스 속성에 액세스 하는 것을 나타냅니다. 인스턴스 속성을 설정 __init__하고 인스턴스 메소드에서 읽거나 변경하는 것이 일반적 입니다. 그렇기 때문에 여러분이 selfals에 첫 번째 인수를 전달하는 이유 def Change입니다.

또 다른 해결책은 다음과 같은 정적 메소드를 작성하는 것입니다.

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.variable = PassByReference.Change(self.variable)
        print self.variable

    @staticmethod
    def Change(var):
        var = 'Changed'
        return var

언어가 가능하지는 않지만 참조로 객체를 전달하는 작은 트릭이 있습니다. Java에서도 작동하며 하나의 항목이있는 목록입니다. ;-)

class PassByReference:
    def __init__(self, name):
        self.name = name

def changeRef(ref):
    ref[0] = PassByReference('Michael')

obj = PassByReference('Peter')
print obj.name

p = [obj] # A pointer to obj! ;-)
changeRef(p)

print p[0].name # p->name

추악한 해킹이지만 작동합니다. ;-피

다음 방법을 사용하여 두 개의 포트란 코드를 Python으로 빠르게 변환했습니다. 사실, 원래의 질문이 제기되었을 때 참조로 전달되지는 않지만 경우에 따라 간단한 해결 방법입니다.

a=0
b=0
c=0
def myfunc(a,b,c):
    a=1
    b=2
    c=3
    return a,b,c

a,b,c = myfunc(a,b,c)
print a,b,c

참조로 전달하는 것은 파이썬에 잘 맞지 않으며 거의 ​​사용되지 않아야하지만 실제로는 현재 로컬 변수에 할당 된 객체를 가져 오거나 호출 된 함수 내부에서 로컬 변수를 다시 할당하기 위해 작동 할 수있는 해결 방법이 있습니다.

기본 아이디어는 해당 액세스를 수행 할 수 있고 다른 함수에 객체로 전달되거나 클래스에 저장 될 수있는 함수를 갖는 것입니다.

한 가지 방법은 랩퍼 함수에서 ( global글로벌 변수) 또는 nonlocal(함수의 로컬 변수)를 사용하는 것입니다.

def change(wrapper):
    wrapper(7)

x = 5
def setter(val):
    global x
    x = val
print(x)

del변수 를 읽고 쓰는 데 동일한 아이디어가 적용됩니다 .

읽기 만하면 lambda: x호출 할 때 x의 현재 값을 반환하는 호출 가능을 반환 하는 짧은 방법이 있습니다 . 이것은 먼 옛날 언어에서 사용 된 "이름으로 전화"와 다소 비슷합니다.

변수에 액세스하기 위해 3 개의 래퍼를 전달하는 것은 다소 까다로워서 프록시 속성이있는 클래스로 래핑 될 수 있습니다.

class ByRef:
    def __init__(self, r, w, d):
        self._read = r
        self._write = w
        self._delete = d
    def set(self, val):
        self._write(val)
    def get(self):
        return self._read()
    def remove(self):
        self._delete()
    wrapped = property(get, set, remove)

# left as an exercise for the reader: define set, get, remove as local functions using global / nonlocal
r = ByRef(get, set, remove)
r.wrapped = 15

파이썬의 "반사"지원을 통해 해당 범위에서 명시 적으로 함수를 정의하지 않고도 주어진 범위에서 이름 / 변수를 재 할당 할 수있는 객체를 얻을 수 있습니다.

class ByRef:
    def __init__(self, locs, name):
        self._locs = locs
        self._name = name
    def set(self, val):
        self._locs[self._name] = val
    def get(self):
        return self._locs[self._name]
    def remove(self):
        del self._locs[self._name]
    wrapped = property(get, set, remove)

def change(x):
    x.wrapped = 7

def test_me():
    x = 6
    print(x)
    change(ByRef(locals(), "x"))
    print(x)

여기서 ByRef클래스는 사전 액세스를 래핑합니다. 따라서 속성 액세스 wrapped는 전달 된 사전의 항목 액세스로 변환됩니다. 내장 결과 locals와 로컬 변수의 이름을 전달하면 로컬 변수에 액세스하게됩니다. 3.5의 python 문서는 사전을 변경해도 작동하지 않을 수도 있지만 나에게 도움이되는 것으로 보입니다.

파이썬이 값과 그에 대한 참조를 처리하는 방식에서 임의의 인스턴스 속성을 참조 할 수있는 유일한 방법은 이름입니다

class PassByReferenceIsh:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print self.variable

    def change(self, var):
        self.__dict__[var] = 'Changed'

실제 코드에서는 물론 dict 조회에 오류 검사를 추가합니다.

사전은 참조로 전달되므로 dict 변수를 사용하여 참조 된 값을 그 안에 저장할 수 있습니다.

# returns the result of adding numbers `a` and `b`
def AddNumbers(a, b, ref): # using a dict for reference
    result = a + b
    ref['multi'] = a * b # reference the multi. ref['multi'] is number
    ref['msg'] = "The result: " + str(result) + " was nice!" # reference any string (errors, e.t.c). ref['msg'] is string
    return result # return the sum

number1 = 5
number2 = 10
ref = {} # init a dict like that so it can save all the referenced values. this is because all dictionaries are passed by reference, while strings and numbers do not.

sum = AddNumbers(number1, number2, ref)
print("sum: ", sum)             # the return value
print("multi: ", ref['multi'])  # a referenced value
print("msg: ", ref['msg'])      # a referenced value

Python의 Pass-By-Reference는 C ++ / Java의 참조에 의한 pass의 개념과는 상당히 다릅니다.

• Java & C # : 기본 유형 (문자열 포함) 값으로 전달 (복사), 참조 유형은 참조 (주소 사본)로 전달되므로 호출 된 함수의 매개 변수에서 작성된 모든 변경 사항은 호출자에게 표시됩니다.
• C ++ : 참조 별 또는 값별이 모두 허용됩니다. 매개 변수가 참조로 전달 된 경우 매개 변수가 const로 전달되었는지 여부에 따라 매개 변수를 수정하거나 수정할 수 없습니다. 그러나 const 또는 not 매개 변수는 객체에 대한 참조를 유지하며 호출 된 함수 내에서 다른 객체를 가리 키도록 참조를 할당 할 수 없습니다.
• Python : Python은 "객체 참조에 의한 통과"이며, "객체 참조는 값으로 전달됩니다."[읽기] 1. 호출자와 함수는 모두 동일한 객체를 참조하지만 함수의 매개 변수는 호출자의 객체 사본을 보유하는 새로운 변수입니다. C ++과 마찬가지로 매개 변수는 수정되거나 기능하지 않을 수 있습니다. 이는 전달 된 객체의 유형에 따라 다릅니다. 예를 들어; 불변 객체 유형은 호출 된 함수에서 수정할 수 없지만 변경 가능한 객체는 업데이트하거나 다시 초기화 할 수 있습니다. 변경 가능한 변수를 업데이트하거나 재 할당 / 재 초기화하는 것의 중요한 차이점은 업데이트 된 값은 호출 된 함수에 다시 반영되지만 다시 초기화 된 값은 그렇지 않습니다. 새로운 객체를 변경 가능한 변수에 할당하는 범위는 파이썬의 함수에 국한됩니다. @ blair-conrad가 제공 한 예는 이것을 이해하는 데 좋습니다.

예제는 객체 지향적이므로 비슷한 결과를 얻기 위해 다음과 같이 변경할 수 있습니다.

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print(self.variable)

    def change(self, var):
        setattr(self, var, 'Changed')

# o.variable will equal 'Changed'
o = PassByReference()
assert o.variable == 'Changed'

내부적으로 객체 속성이 인스턴스 사전에 저장되기 때문에 빈 객체를 인스턴스로 사용 하여 참조 객체를 저장할 수 있습니다 . 예를 참조하십시오.

class RefsObj(object):
    "A class which helps to create references to variables."
    pass

...

# an example of usage
def change_ref_var(ref_obj):
    ref_obj.val = 24

ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)

예를 들어 C ++에서 알려진 것처럼 참조를 시뮬레이션하는 방법은 "update"함수를 사용하여 실제 변수 (또는 "name") 대신 전달하는 것입니다.

def need_to_modify(update):
    update(42) # set new value 42
    # other code

def call_it():
    value = 21
    def update_value(new_value):
        nonlocal value
        value = new_value
    need_to_modify(update_value)
    print(value) # prints 42

이것은 "아웃-아웃 참조"또는 여러 스레드 / 프로세스가있는 상황 (업데이트 기능 스레드 / 멀티 프로세싱을 안전하게 함)에 주로 유용합니다.

분명히 위 의 값을 읽을 수는 없으며 업데이트 만 가능합니다.