Аргументы передаются по присваиванию . Обоснование этого двоякое:
- передаваемый параметр на самом деле является ссылкой на объект (но ссылка передается по значению)
- некоторые типы данных являются изменяемыми, но другие не являются
Итак:
Если вы передадите объект mutable в метод, метод получит ссылку на этот же объект, и вы сможете изменить его на радость своего сердца, но если вы перепроверете ссылку в методе внешняя область не будет ничего знать об этом, и после того, как вы закончите, внешняя ссылка все еще будет указывать на исходный объект
Если вы передадите неизменяемый объект методу, вы все равно не сможете повторно привязать внешнюю ссылку и даже не можете мутировать объект.
Чтобы было еще яснее, давайте приведем несколько примеров.
Список - изменяемый тип
Попробуем изменить список, который был передан методу:
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.
String - неизменный тип
Он неизменен, поэтому мы ничего не можем сделать, чтобы изменить содержимое строки
Теперь давайте попробуем изменить ссылку
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])
Хотя это кажется немного громоздким.