Bagaimana untuk lulus pembolehubah dengan rujukan?

Kandungan soalan

Saya menulis kelas ini untuk ujian:

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

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

Apabila saya cuba mencipta contoh, outputnya ialah original。所以python中的参数似乎是按值传递的。那是对的吗？如何修改代码才能达到引用传递的效果，使得输出为changed?

_{Kadang-kadang orang terkejut dengan x = 1 这样的代码（其中 x 是参数名称）不会影响调用者的参数，但像 x[0] = 1 这样的代码却会影响调用者的参数。发生这种情况是因为尽管有 = suka sintaks, tetapi tugasan item dan tugasan hirisan ialah kaedah mengubah}objek sedia ada, bukannya menetapkan semula pembolehubah. Lihat Mengapa fungsi boleh mengubah suai beberapa parameter seperti yang dilihat oleh pemanggil, tetapi bukan yang lain? Ketahui lebih lanjut.

Juga lihat Apakah perbezaan antara lulus dengan rujukan dan lulus dengan nilai? Untuk perbincangan terminologi yang penting dan bebas bahasa.

Jawapan yang betul

parameter adalah diluluskan oleh tugasan

. Terdapat dua sebab di sebalik ini:

1. Parameter yang diluluskan sebenarnya adalah rujukan
kepada objek (tetapi rujukan itu diluluskan oleh nilai)
Sesetengah jenis data boleh berubah, tetapi yang lain tidak

Jadi:

• Jika anda melepasi objek bolehubah

  kepada kaedah, kaedah itu akan mendapat rujukan kepada objek yang sama dan anda boleh mengubahnya mengikut cara yang anda mahu, tetapi jika anda berada di dalam kaedah, skop luar tidak mengetahui apa-apa mengenainya Selepas itu, rujukan luaran masih akan menunjuk ke objek asal.

• Jika anda menghantar objek tidak berubah

  kepada kaedah, anda masih tidak boleh mengikat semula rujukan luaran atau menukar objek itu.

Untuk menggambarkan perkara ini dengan lebih jelas, mari berikan beberapa contoh.

Senarai - jenis boleh ubah

Mari cuba ubah suai senarai yang diserahkan kepada kaedah:

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)

Keluaran:

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

outer_listMemandangkan parameter yang diluluskan adalah rujukan kepada

dan bukan salinannya, kita boleh menggunakan kaedah senarai mutasi untuk menukarnya dan perubahan itu ditunjukkan dalam skop luar.

Sekarang mari kita lihat apa yang berlaku apabila kita cuba menukar rujukan yang dihantar sebagai parameter:

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)

Keluaran:

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_listMemandangkan parameter the_list diluluskan mengikut nilai, memberikan senarai baharu kepadanya tidak akan memberi kesan pada kod di luar kaedah. the_list ialah salinan daripada apa yang

merujuk, kami menjadikan the_list menghala ke senarai baharu, tetapi kami tidak boleh menukar ke mana

menunjuk ke.

String - jenis tidak berubah

Ia tidak berubah jadi kita tidak boleh menukar kandungan rentetan

Sekarang, mari cuba ubah rujukan

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)

Keluaran: the_string 参数是按值传递的，因此为其分配新字符串不会对方法外部的代码看到任何影响。 the_string 是 outer_string 引用的副本，我们让 the_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

Sekali lagi, kerana di mana

mata.

Saya harap ini menjadikan perkara lebih jelas.

EDIT:

Seseorang menunjukkan bahawa ini tidak menjawab soalan asal @david: "Adakah ada apa-apa yang boleh saya lakukan untuk lulus pembolehubah dengan rujukan sebenar?". Mari bekerja keras.

Bagaimana kita nak selesaikan masalah ini?

Seperti yang ditunjukkan oleh jawapan @andrea, anda boleh mengembalikan nilai baharu. Ini tidak mengubah cara kandungan dihantar, tetapi ia membolehkan anda mendapatkan maklumat yang anda inginkan:

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)

Jika anda benar-benar ingin mengelak daripada menggunakan nilai pulangan, anda boleh mencipta kelas untuk menyimpan nilai anda dan menghantarnya kepada fungsi atau menggunakan kelas sedia ada, seperti senarai:

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

🎜Walaupun ini kelihatan agak menyusahkan. 🎜

Atas ialah kandungan terperinci Bagaimana untuk lulus pembolehubah dengan rujukan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!