Документація Python видається незрозумілою щодо передачі параметрів за посиланням чи значенням, і наступний код створює незмінене значення "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вказано, не було.

Я сподіваюся, що це трохи прояснить справи.

EDIT: Помічено, що це не відповідає на питання, яке @David спочатку запитував: "Чи можна щось зробити, щоб передати змінну за фактичною посиланням?". Давайте попрацюємо над цим.

Як ми можемо обійти це?

Як показує відповідь @ Андреа, ви можете повернути нове значення. Це не змінює спосіб передачі речей, але дозволяє отримувати потрібну інформацію:

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

Хоча це здається трохи громіздким.

Проблема виникає з нерозуміння того, які змінні є в Python. Якщо ви звикли до більшості традиційних мов, у вас є ментальна модель того, що відбувається в наступній послідовності:

a = 1
a = 2

Ви вважаєте, що aце місце пам'яті, яке зберігає значення 1, а потім оновляється для зберігання значення 2. Це не так, як працюють у Python. Швидше, 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 поводиться зі змінними та параметрами.

Це не є ні прохідною цінністю, ні прохідною посиланням - це дзвінок за об'єктом. Дивіться це, Фредрік Лунд:

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 (він же Фредрік Лунд) описав змінний стиль проходження Python як виклик за об'єктом: http://effbot.org/zone/call-by-object.htm

Об'єкти виділяються на купі, а вказівники на них можуть передаватися де завгодно.

• Коли ви робите таке завдання, як x = 1000, наприклад , створюється запис у словнику, який відображає рядок "x" у поточному просторі імен вказівник на цілий об'єкт, що містить тисячу.

• Коли ви оновлюєте "x" за допомогою x = 2000, створюється новий цілий об'єкт і словник оновлюється, щоб вказувати на новий об'єкт. Старий об'єкт на тисячу є незмінним (і може бути, а може і не бути живим, залежно від того, що ще щось стосується об'єкта).

• Коли ви робите нове завдання, наприклад y = x, створюється новий словник "y", який вказує на той самий об'єкт, що і запис для "x".

• Об'єкти, такі як рядки та цілі числа, незмінні . Це просто означає, що немає методів, які могли б змінити об'єкт після його створення. Наприклад, як тільки буде створено цілий об'єкт тисяча, він ніколи не зміниться. Математика виконується шляхом створення нових цілих об'єктів.

• Об'єкти, такі як списки, змінюються . Це означає, що вміст об'єкта може бути змінено будь-чим, що вказує на об’єкт. Наприклад, x = []; y = x; x.append(10); print yбуде друкувати [10]. Порожній список створено. І "х", і "у" вказують на один і той же список. Метод додавання мутує (оновлює) об’єкт списку (як-от додавання запису до бази даних), і результат видно як "x", так і "y" (подібно до того, як оновлення бази даних було б видно при кожному з'єднанні з цією базою даних).

Сподіваємось, що з’ясує це питання для вас.

Технічно Python завжди використовує прохідні значення . Я буду повторювати свою іншу відповідь, щоб підтримати мою заяву.

Python завжди використовує прохідні значення. Не є винятком. Будь-яке призначення змінної означає копіювання опорного значення. Не виняток. Будь-яка змінна - це ім'я, пов'язане з опорним значенням. Завжди.

Ви можете думати про опорне значення як адресу цільового об'єкта. Адреса автоматично використовується, коли використовується. Таким чином, працюючи з опорним значенням, здається, ви працюєте безпосередньо з цільовим об’єктом. Але між ними завжди є посилання, ще крок більше, щоб перейти до цілі.

Ось приклад, який доводить, що Python використовує проходження за посиланням:

Якщо аргумент був переданий за значенням, зовнішній lstне міг бути змінений. Зелені - це цільові об'єкти (чорний - це значення, що зберігається всередині, червоний - тип об'єкта), жовтий - це пам'ять, опорне значення якої всередині - намальовано як стрілка. Синя суцільна стрілка - це опорне значення, яке було передане функції (через штрихову синю стрілку). Потворний темно-жовтий - це внутрішній словник. (Насправді він може бути намальований також як зелений еліпс. Колір і форма лише кажуть, що це внутрішня.)

Ви можете використовувати id()вбудовану функцію, щоб дізнатися, що таке опорне значення (тобто адреса цільового об’єкта).

У складених мовах змінна - це простір пам’яті, який здатний фіксувати значення типу. У Python змінна - це ім'я (захоплене внутрішньо як рядок), пов'язане з опорною змінною, що містить опорне значення для цільового об'єкта. Ім'я змінної є ключем у внутрішньому словнику, частина значення цього елемента словника зберігає опорне значення для цілі.

Довідкові значення приховано в Python. Немає явного типу користувача для зберігання еталонного значення. Однак ви можете використовувати елемент списку (або елемент будь-якого іншого відповідного типу контейнера) як опорну змінну, оскільки всі контейнери зберігають елементи також як посилання на цільові об'єкти. Іншими словами, елементи насправді не містяться всередині контейнера - лише посилання на елементи є.

У Python змінних немає

Ключ до розуміння проходження параметрів - це припинити думати про "змінні". У Python є імена та об'єкти, і вони разом виглядають як змінні, але корисно завжди розрізняти три.

1. У Python є імена та об'єкти.
2. Призначення прив'язує ім'я до об'єкта.
3. Передача аргументу у функцію також прив'язує ім'я (ім'я параметра параметра) до об'єкта.

Це все, що там є. Зміна цього питання не має значення для цього питання.

Приклад:

a = 1

Це пов'язує ім'я aз об'єктом типу цілого числа, який містить значення 1.

b = x

Це пов'язує ім'я bз тим самим об'єктом, до якого ім'я xв даний час пов'язане. Після цього ім'я bвже не має нічого спільного з ім'ям x.

Дивіться розділи 3.1 та 4.2 у посиланні на мову Python 3.

Як прочитати приклад у питанні

У коді, наведеному у запитанні, оператор self.Change(self.variable)пов'язує ім'я var(в області функції Change) до об'єкта, який містить значення, 'Original'і присвоєння var = 'Changed'(в тілі функції Change) присвоює це те саме ім'я знову: якомусь іншому об'єкту (що трапляється щоб також тримати рядок, але цілком могло бути щось інше).

Як пройти посилання

Отже, якщо річ, яку ви хочете змінити, - це об'єкт, що змінюється, проблем не виникає, оскільки все фактично передається шляхом посилання.

Якщо це незмінний об'єкт (наприклад, bool, число, рядок), шлях слід загорнути в об'єкт, що змінюється.
Швидке і брудне рішення для цього - це одноелементний список (замість того self.variable, щоб передати [self.variable]та змінити функцію var[0]).
Більш пітонічним підходом було б запровадити тривіальний клас з однозначними ознаками. Функція отримує екземпляр класу і маніпулює атрибутом.

Простий трюк, який я зазвичай використовую - просто загорнути його в список:

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

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

(Так, я знаю, що це може бути незручно, але іноді це досить просто.)

(редагувати - Блер оновив свою надзвичайно популярну відповідь, щоб вона тепер була точною)

Я думаю, що важливо відзначити, що нинішня посада з найбільшою кількістю голосів (Блер Конрад), хоча і є коректною щодо її результату, вводить в оману та є невірно обмеженою на основі її визначень. Хоча існує багато мов (наприклад, C), які дозволяють користувачеві пройти посилання або передати значення, Python не є однією з них.

Відповідь Девіда Курнопо вказує на реальну відповідь і пояснює, чому поведінка на посаді Блера Конрада здається правильною, а визначення - ні.

Наскільки Python передається за значенням, всі мови передаються за значенням, оскільки має бути надіслана частина даних (будь то "значення" або "посилання"). Однак це не означає, що Python передається за значенням у тому сенсі, що програміст на C подумає про це.

Якщо ви хочете поведінки, відповідь Блера Конрада чудова. Але якщо ви хочете дізнатися гайки та болти, чому Python не є ні прохідним, ні посиланням, прочитайте відповідь Девіда Курно.

Тут ви отримали кілька справді хороших відповідей.

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. Наведений нижче фрагмент коду показує, що станеться, якщо ви зміните структуру даних, на яку вказує, varі 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']
>>> 

Я впевнений, що хтось ще може це прояснити далі.

Схема передачі по призначенню Python не зовсім така, як параметр посилальних параметрів 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

Тут багато розумінь у відповідях, але, думаю, додатковий пункт тут чітко не згадується. Цитування з python документації 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використовується в Python.
Кожного разу, коли ви передаєте об'єкт функції, сам об'єкт передається (об'єкт в Python - це насправді те, що ви б назвали значенням в інших мовах програмування), а не посилання на цей об'єкт. Іншими словами, коли ви телефонуєте:

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)

що, очевидно, змінить об’єкт. Ця відповідь це добре пояснює.

Окрім усіх чудових пояснень того, як цей матеріал працює в Python, я не бачу простої пропозиції щодо проблеми. Оскільки ви, здається, створюєте об'єкти та екземпляри, пітонічний спосіб обробки змінних екземплярів та їх зміна полягає в наступному:

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

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

У методах, наприклад, ви зазвичай посилаєтесь selfна доступ до атрибутів екземпляра. Зазвичай встановлювати атрибути екземплярів __init__і читати чи змінювати їх в методах екземплярів. Ось чому ви також передаєте selfперший аргумент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

Це некрасивий хакер, але він працює. ;-P

Я використовував наступний метод, щоб швидко перетворити пару кодів Fortran в 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

Хоча пропуск за посиланням - це ніщо, що добре вписується в python, і його слід рідко використовувати, є деякі обхідні шляхи, які насправді можуть працювати, щоб об'єкт, який в даний час присвоюється локальній змінній, або навіть переназначити локальну змінну зсередини викликаної функції.

Основна ідея - це функція, яка може робити цей доступ і може бути передана як об'єкт в інші функції або збережена в класі.

Один із способів - використання 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і ім'я локальної змінної, це закінчується доступ до локальної змінної. Документація python на 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

Pass-By-Reference у Python сильно відрізняється від концепції передачі посилань у C ++ / Java.

• Java & C #: примітивні типи (включають рядок) передають за значенням (копія), Тип посилання передається за посиланням (копія адреси), тому всі зміни, внесені в параметр у виклику функції, видимі абоненту.
• C ++: Дозволені як прохідні посилання, так і значення пропускання. Якщо параметр передається за посиланням, ви можете його змінити чи не залежно від того, передано параметр як const чи ні. Однак, const чи ні, параметр підтримує посилання на об'єкт, а посилання не може бути призначене для вказівки на інший об'єкт у межах викликаної функції.
• 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 ++, полягає у використанні функції "оновлення" та передачі її замість фактичної змінної (а точніше, "імені"):

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

Це, в основному, корисно для "посилань, що використовуються лише", або в ситуації з декількома потоками / процесами (роблячи безпеку потоку функції оновлення / багатопроцесорної обробки).

Очевидно, що вищесказане не дозволяє прочитати значення, а лише оновити його.