A documentação do Python parece pouco clara sobre se os parâmetros são passados ​​por referência ou valor, e o código a seguir produz o valor inalterado 'Original'

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

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

Existe algo que eu possa fazer para passar a variável por referência real?

Os argumentos são passados ​​por atribuição . A lógica por trás disso é dupla:

1. o parâmetro passado é realmente uma referência a um objeto (mas a referência é passada por valor)
2. alguns tipos de dados são mutáveis, mas outros não

Assim:

• Se você passar um objeto mutável para um método, o método fará uma referência ao mesmo objeto e você poderá modificá-lo para o deleite do seu coração, mas se você religar a referência no método, o escopo externo não saberá mais nada sobre ele e depois pronto, a referência externa ainda apontará para o objeto original.

• Se você passar um objeto imutável para um método, ainda não poderá religar a referência externa e nem mesmo modificar o objeto.

Para deixar ainda mais claro, vamos dar alguns exemplos.

Lista - um tipo mutável

Vamos tentar modificar a lista que foi passada para um método:

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)

Resultado:

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

Como o parâmetro transmitido é uma referência outer_list, e não uma cópia dele, podemos usar os métodos da lista de mutação para alterá-lo e ter as alterações refletidas no escopo externo.

Agora vamos ver o que acontece quando tentamos alterar a referência que foi passada como parâmetro:

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)

Resultado:

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

Como o the_listparâmetro foi passado por valor, atribuir uma nova lista a ele não teve nenhum efeito que o código fora do método pudesse ver. A the_listera uma cópia da outer_listreferência, e tivemos the_listapontam para uma nova lista, mas não havia nenhuma maneira de mudar o local onde outer_listpontiagudo.

String - um tipo imutável

É imutável, então não há nada que possamos fazer para alterar o conteúdo da string

Agora, vamos tentar mudar a referência

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)

Resultado:

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

Novamente, como o the_stringparâmetro foi passado por valor, atribuir uma nova string a ele não teve nenhum efeito que o código fora do método pudesse ver. A the_stringera uma cópia da outer_stringreferência, e tivemos the_stringapontam para uma nova seqüência, mas não havia nenhuma maneira de mudar o local onde outer_stringpontiagudo.

Espero que isso esclareça um pouco as coisas.

EDIT: Observou-se que isso não responde à pergunta que @David originalmente perguntou: "Existe algo que eu possa fazer para passar a variável por referência real?". Vamos trabalhar nisso.

Como contornar isso?

Como mostra a resposta de Andrea, você pode retornar o novo valor. Isso não muda a maneira como as coisas são transmitidas, mas permite que você obtenha as informações que deseja:

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)

Se você realmente deseja evitar o uso de um valor de retorno, pode criar uma classe para manter seu valor e passá-lo para a função ou usar uma classe existente, como uma lista:

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

Embora isso pareça um pouco complicado.

O problema vem de um mal-entendido de quais variáveis ​​existem no Python. Se você está acostumado com a maioria dos idiomas tradicionais, possui um modelo mental do que acontece na seguinte sequência:

a = 1
a = 2

Você acredita que esse aé um local de memória que armazena o valor 1e é atualizado para armazenar o valor 2. Não é assim que as coisas funcionam no Python. Em vez disso, acomeça como uma referência a um objeto com o valor 1e depois é reatribuído como uma referência a um objeto com o valor 2. Esses dois objetos podem continuar a coexistir, embora anão se refiram mais ao primeiro; de fato, eles podem ser compartilhados por qualquer número de outras referências dentro do programa.

Quando você chama uma função com um parâmetro, é criada uma nova referência que se refere ao objeto transmitido. Isso é separado da referência que foi usada na chamada de função, portanto, não há como atualizar essa referência e fazê-la se referir a um parâmetro. novo objeto. No seu exemplo:

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

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

self.variableé uma referência ao objeto de sequência 'Original'. Quando você chama, Changecria uma segunda referência varao objeto. Dentro da função, você reatribui a referência vara um objeto de sequência diferente 'Changed', mas a referência self.variableé separada e não muda.

A única maneira de contornar isso é passar um objeto mutável. Como as duas referências se referem ao mesmo objeto, quaisquer alterações no objeto são refletidas nos dois lugares.

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

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

Eu achei as outras respostas bastante longas e complicadas, então criei este diagrama simples para explicar como o Python trata variáveis ​​e parâmetros.

Não é passagem por valor ou passagem por referência - é chamada por objeto. Veja isto, de Fredrik Lundh:

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

Aqui está uma citação significativa:

"... variáveis ​​[nomes] não são objetos; elas não podem ser indicadas por outras variáveis ​​ou referidas por objetos."

No seu exemplo, quando o Changemétodo é chamado - um espaço para nome é criado para ele; e varse torna um nome, dentro desse espaço de nome, para o objeto string 'Original'. Esse objeto, em seguida, tem um nome em dois espaços para nome. Em seguida, var = 'Changed'vincula var- se a um novo objeto de sequência e, portanto, o espaço de nome do método esquece 'Original'. Finalmente, esse espaço para nome é esquecido e a string 'Changed'junto com ele.

Pense nas coisas que estão sendo passadas por atribuição em vez de por referência / por valor. Dessa forma, é sempre claro o que está acontecendo, desde que você entenda o que acontece durante a tarefa normal.

Portanto, ao passar uma lista para uma função / método, a lista é atribuída ao nome do parâmetro. Anexar à lista resultará na modificação da lista. A reatribuição da lista dentro da função não alterará a lista original, pois:

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

Como tipos imutáveis ​​não podem ser modificados, eles parecem passados ​​por valor - passar um int para uma função significa atribuir o int ao parâmetro da função. Você só pode reatribuir isso, mas isso não altera o valor das variáveis ​​originais.

Effbot (aka Fredrik Lundh) descreveu o estilo de passagem variável do Python como chamada por objeto: http://effbot.org/zone/call-by-object.htm

Os objetos são alocados na pilha e os ponteiros para eles podem ser passados ​​para qualquer lugar.

• Quando você faz uma atribuição como x = 1000, é criada uma entrada de dicionário que mapeia a cadeia "x" no espaço para nome atual para um ponteiro para o objeto inteiro que contém mil.

• Quando você atualiza "x" com x = 2000, um novo objeto inteiro é criado e o dicionário é atualizado para apontar para o novo objeto. O objeto antigo de mil é inalterado (e pode ou não estar vivo, dependendo se algo mais se refere ao objeto).

• Quando você executa uma nova atribuição, como y = x, é criada uma nova entrada de dicionário "y" que aponta para o mesmo objeto que a entrada de "x".

• Objetos como strings e inteiros são imutáveis . Isso significa simplesmente que não há métodos que possam alterar o objeto depois que ele foi criado. Por exemplo, uma vez que o objeto inteiro mil seja criado, ele nunca será alterado. A matemática é feita criando novos objetos inteiros.

• Objetos como listas são mutáveis . Isso significa que o conteúdo do objeto pode ser alterado por qualquer coisa que aponte para o objeto. Por exemplo, x = []; y = x; x.append(10); print yimprimirá [10]. A lista vazia foi criada. "X" e "y" apontam para a mesma lista. O método append modifica (atualiza) o objeto de lista (como adicionar um registro a um banco de dados) e o resultado é visível para "x" e "y" (assim como uma atualização de banco de dados seria visível para todas as conexões com esse banco de dados).

Espero que esclareça o problema para você.

Tecnicamente, o Python sempre usa valores de passagem por referência . Vou repetir minha outra resposta para apoiar minha declaração.

O Python sempre usa valores de passagem por referência. Não há nenhuma exceção. Qualquer atribuição de variável significa copiar o valor de referência. Sem exceção. Qualquer variável é o nome vinculado ao valor de referência. Sempre.

Você pode pensar em um valor de referência como o endereço do objeto de destino. O endereço é desreferenciado automaticamente quando usado. Dessa forma, trabalhando com o valor de referência, parece que você trabalha diretamente com o objeto de destino. Mas sempre há uma referência no meio, mais um passo para pular para o alvo.

Aqui está o exemplo que prova que o Python usa a passagem por referência:

Se o argumento foi passado por valor, o externo lstnão pôde ser modificado. O verde são os objetos de destino (o preto é o valor armazenado no interior, o vermelho é o tipo de objeto), o amarelo é a memória com o valor de referência interno - desenhado como a seta. A seta sólida azul é o valor de referência que foi passado para a função (através do caminho da seta azul tracejada). O feio amarelo escuro é o dicionário interno. (Na verdade, ele também pode ser desenhado como uma elipse verde. A cor e a forma apenas dizem que é interna.)

Você pode usar a id()função interna para saber qual é o valor de referência (ou seja, o endereço do objeto de destino).

Em linguagens compiladas, uma variável é um espaço de memória capaz de capturar o valor do tipo. No Python, uma variável é um nome (capturado internamente como uma string) vinculado à variável de referência que mantém o valor de referência no objeto de destino. O nome da variável é a chave no dicionário interno, a parte do valor desse item de dicionário armazena o valor de referência no destino.

Os valores de referência estão ocultos no Python. Não há nenhum tipo explícito de usuário para armazenar o valor de referência. No entanto, você pode usar um elemento de lista (ou elemento em qualquer outro tipo de contêiner adequado) como a variável de referência, porque todos os contêineres armazenam os elementos também como referências aos objetos de destino. Em outras palavras, os elementos não estão realmente contidos no contêiner - apenas as referências aos elementos.

Não há variáveis ​​no Python

A chave para entender a passagem de parâmetros é parar de pensar em "variáveis". Existem nomes e objetos em Python e juntos eles parecem variáveis, mas é útil sempre distinguir os três.

1. Python tem nomes e objetos.
2. A atribuição vincula um nome a um objeto.
3. Passar um argumento para uma função também vincula um nome (o nome do parâmetro da função) a um objeto.

Isso é tudo o que existe. A mutabilidade é irrelevante para esta questão.

Exemplo:

a = 1

Isso vincula o nome aa um objeto do tipo número inteiro que contém o valor 1.

b = x

Isso vincula o nome bao mesmo objeto ao qual o nome xestá atualmente vinculado. Depois, o nome bnão tem mais nada a ver com o nome x.

Consulte as seções 3.1 e 4.2 na referência da linguagem Python 3.

Como ler o exemplo na pergunta

No código mostrado na pergunta, a instrução self.Change(self.variable)vincula o nome var(no escopo da função Change) ao objeto que contém o valor 'Original'e a atribuição var = 'Changed'(no corpo da função Change) atribui o mesmo nome novamente: a algum outro objeto (o que acontece segurar uma corda também, mas poderia ter sido algo totalmente diferente).

Como passar por referência

Portanto, se o que você deseja alterar é um objeto mutável, não há problema, pois tudo é efetivamente passado por referência.

Se for um objeto imutável (por exemplo, um bool, número, string), o caminho a seguir é envolvê-lo em um objeto mutável.
A solução rápida e suja para isso é uma lista de um elemento (em vez de self.variablepassar [self.variable]e modificar a função var[0]).
A abordagem mais pitônica seria a introdução de uma classe trivial de um atributo. A função recebe uma instância da classe e manipula o atributo.

Um truque simples que normalmente uso é envolvê-lo em uma lista:

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

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

(Sim, eu sei que isso pode ser inconveniente, mas às vezes é simples o suficiente para fazer isso.)

(editar - Blair atualizou sua resposta enormemente popular para que agora seja precisa)

Penso que é importante observar que a publicação atual com mais votos (de Blair Conrad), embora correta em relação ao resultado, é enganosa e limítrofe incorreta com base em suas definições. Embora existam muitas linguagens (como C) que permitem ao usuário passar por referência ou passar por valor, o Python não é um deles.

A resposta de David Cournapeau aponta para a resposta real e explica por que o comportamento no post de Blair Conrad parece estar correto, enquanto as definições não são.

Na medida em que o Python é transmitido por valor, todas as linguagens são transmitidas por valor, pois alguns dados (seja um "valor" ou uma "referência") devem ser enviados. No entanto, isso não significa que o Python seja transmitido por valor no sentido em que um programador C pensaria nisso.

Se você quer o comportamento, a resposta de Blair Conrad é boa. Mas se você deseja conhecer os detalhes do porquê o Python não passa por valor ou por referência, leia a resposta de David Cournapeau.

Você tem respostas muito boas aqui.

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

Nesse caso, a variável intitulada varno método Changerecebe uma referência self.variablee você atribui imediatamente uma string a var. Não está mais apontando para self.variable. O seguinte trecho de código mostra o que aconteceria se você modificar a estrutura de dados apontada por vare self.variable, nesse caso, uma lista:

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

Tenho certeza que alguém poderia esclarecer isso ainda mais.

O esquema de passagem por atribuição do Python não é exatamente o mesmo que a opção de parâmetros de referência do C ++, mas acaba sendo muito semelhante ao modelo de passagem de argumentos da linguagem C (e outros) na prática:

• Argumentos imutáveis ​​são efetivamente passados ​​" por valor ". Objetos como números inteiros e seqüências de caracteres são passados ​​por referência a objeto, e não por cópia, mas como você não pode alterar objetos imutáveis ​​de qualquer maneira, o efeito é como fazer uma cópia.
• Argumentos mutáveis ​​são efetivamente passados ​​" por ponteiro ". Objetos como listas e dicionários também são passados ​​por referência a objetos, semelhante à maneira como C passa matrizes como ponteiros - objetos mutáveis ​​podem ser alterados no lugar na função, assim como matrizes C.

Como você pode indicar, precisa ter um objeto mutável, mas deixe-me sugerir que você verifique as variáveis ​​globais, pois elas podem ajudá-lo ou até mesmo resolver esse tipo de problema!

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

exemplo:

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

Muitas idéias são respondidas aqui, mas acho que um ponto adicional não é claramente mencionado aqui explicitamente. Citando a partir da documentação python https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

"No Python, variáveis ​​que são referenciadas apenas dentro de uma função são implicitamente globais. Se uma variável recebe um novo valor em qualquer lugar do corpo da função, é assumido como local. Se uma variável receber um novo valor dentro da função, a variável é implicitamente local e é necessário declará-la explicitamente como "global". Embora um pouco surpreendente a princípio, uma consideração momentânea explica isso: por um lado, exigir global para variáveis ​​atribuídas fornece uma barreira contra efeitos colaterais indesejados. por outro lado, se global fosse necessário para todas as referências globais, você estaria usando global o tempo todo.Você teria que declarar global todas as referências a uma função interna ou a um componente de um módulo importado. derrotaria a utilidade da declaração global para identificar efeitos colaterais ".

Mesmo ao passar um objeto mutável para uma função, isso ainda se aplica. E, para mim, explica claramente a razão da diferença de comportamento entre atribuir ao objeto e operar no objeto na função.

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)

dá:

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

A atribuição a uma variável global que não é declarada global, cria um novo objeto local e interrompe o vínculo com o objeto original.

Aqui está a explicação simples (espero) do conceito pass by objectusado no Python.
Sempre que você passa um objeto para a função, o próprio objeto é passado (o objeto no Python é na verdade o que você chamaria de valor em outras linguagens de programação), não a referência a esse objeto. Em outras palavras, quando você liga para:

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

my_list = [0, 1]
change_me(my_list)

O objeto atual - [0, 1] (que seria chamado de valor em outras linguagens de programação) está sendo passado. Então, de fato, a função change_metentará fazer algo como:

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

que obviamente não mudará o objeto passado para a função. Se a função estivesse assim:

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

A chamada resultaria em:

[0, 1].append(2)

o que obviamente mudará o objeto. Esta resposta explica bem.

Além de todas as excelentes explicações sobre como essas coisas funcionam no Python, não vejo uma sugestão simples para o problema. Como você parece criar objetos e instâncias, a maneira pitônica de lidar com variáveis ​​de instância e alterá-las é a seguinte:

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

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

Nos métodos de instância, você normalmente se refere selfao acesso aos atributos da instância. É normal definir atributos de instância __init__e ler ou alterá-los nos métodos de instância. É também por isso que você passa selfo primeiro argumento para def Change.

Outra solução seria criar um método estático como este:

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

Há um pequeno truque para passar um objeto por referência, mesmo que a linguagem não o torne possível. Também funciona em Java, é a lista com um item. ;-)

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

É um truque feio, mas funciona. ;-P

Usei o método a seguir para converter rapidamente alguns códigos do Fortran em Python. É verdade que não é passado por referência como a pergunta original foi colocada, mas é uma solução simples em alguns casos.

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

Embora a passagem por referência não seja nada que se encaixe bem no python e deva ser raramente usada, existem algumas soluções alternativas que podem funcionar para obter o objeto atualmente atribuído a uma variável local ou até reatribuir uma variável local de dentro de uma função chamada.

A idéia básica é ter uma função que possa fazer esse acesso e possa ser passada como objeto para outras funções ou armazenada em uma classe.

Uma maneira é usar global(para variáveis ​​globais) ou nonlocal(para variáveis ​​locais em uma função) em uma função de wrapper.

def change(wrapper):
    wrapper(7)

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

A mesma idéia funciona para ler e delescrever uma variável.

Para apenas ler, há ainda uma maneira mais curta de usar, lambda: xque retorna uma chamada que, quando chamada, retorna o valor atual de x. É um pouco como "chamar pelo nome" usado em idiomas no passado distante.

Passar 3 invólucros para acessar uma variável é um pouco complicado, para que eles possam ser agrupados em uma classe que possui um atributo de proxy:

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

O suporte à "reflexão" do Pythons torna possível obter um objeto capaz de reatribuir um nome / variável em um determinado escopo sem definir funções explicitamente nesse escopo:

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)

Aqui, a ByRefclasse envolve um acesso ao dicionário. Portanto, o acesso ao atributo wrappedé traduzido para um acesso ao item no dicionário passado. Ao passar o resultado do builtin localse o nome de uma variável local, isso acaba acessando uma variável local. A documentação do python a partir do 3.5 recomenda que alterar o dicionário pode não funcionar, mas parece funcionar para mim.

dada a maneira como o python lida com valores e referências a eles, a única maneira de referenciar um atributo de instância arbitrário é pelo nome:

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

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

no código real, é claro, você adicionaria a verificação de erros na pesquisa de ditado.

Como os dicionários são passados ​​por referência, você pode usar uma variável dict para armazenar quaisquer valores referenciados dentro dela.

# 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

A passagem por referência em Python é bem diferente do conceito de passagem por referência em C ++ / Java.

• Java & C #: tipos primitivos (incluir cadeia de caracteres) passam por valor (cópia); o tipo de referência é passado por referência (cópia de endereço) para que todas as alterações feitas no parâmetro na função chamada sejam visíveis para o chamador.
• C ++: passagem por referência ou passagem por valor são permitidas. Se um parâmetro for passado por referência, você poderá modificá-lo ou não, dependendo se o parâmetro foi passado como const ou não. No entanto, const ou não, o parâmetro mantém a referência ao objeto e a referência não pode ser atribuída para apontar para um objeto diferente na função chamada.
• Python: Python é "referência por objeto a objeto", do qual se costuma dizer: "As referências a objetos são transmitidas por valor". [Leia aqui] 1. Tanto o chamador quanto a função se referem ao mesmo objeto, mas o parâmetro na função é uma nova variável que está apenas mantendo uma cópia do objeto no chamador. Como o C ++, um parâmetro pode ser modificado ou não funcionar - Isso depende do tipo de objeto passado. por exemplo; Um tipo de objeto imutável não pode ser modificado na função chamada, enquanto um objeto mutável pode ser atualizado ou reinicializado. Uma diferença crucial entre atualizar ou redesignar / reinicializar a variável mutável é que o valor atualizado é refletido de volta na função chamada, enquanto o valor reinicializado não. O escopo de qualquer atribuição de novo objeto a uma variável mutável é local para a função no python. Os exemplos fornecidos por @ blair-conrad são ótimos para entender isso.

Como seu exemplo é orientado a objetos, você pode fazer as seguintes alterações para obter um resultado semelhante:

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'

Você pode simplesmente usar uma classe vazia como uma instância para armazenar objetos de referência, porque os atributos internos dos objetos são armazenados em um dicionário de instância. Veja o exemplo.

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)

Como parece não ser mencionado em nenhum lugar, uma abordagem para simular referências como conhecidas em, por exemplo, C ++, é usar uma função "update" e passar isso em vez da variável real (ou melhor, "nome"):

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

Isso é útil principalmente para "referências somente de saída" ou em uma situação com vários threads / processos (tornando a função de atualização thread / multiprocessamento segura).

Obviamente o acima não permite ler o valor, apenas atualizá-lo.