පැවරුම් මගින් තර්ක සම්මත කරනු ලැබේ . මේ පිටුපස ඇති තාර්කිකත්වය දෙයාකාර ය:
- සම්මත කළ පරාමිතිය ඇත්ත වශයෙන්ම වස්තුවකට යොමු කිරීමකි (නමුත් යොමු කිරීම අගය අනුව සම්මත වේ)
- සමහර දත්ත වර්ග විකෘති වන නමුත් අනෙක් ඒවා එසේ නොවේ
නිසා:
ඔබ විකෘති වස්තුවක් ක්‍රමයකට යොමු කළහොත්, එම ක්‍රමයට එම වස්තුවටම යොමු කිරීමක් ලැබෙන අතර ඔබට එය ඔබේ හදවතේ ප්‍රීතියට විකෘති කළ හැකිය, නමුත් ඔබ එම ක්‍රමවේදය නැවත යොමු කළහොත් පිටත විෂය පථය ඒ ගැන කිසිවක් නොදන්නා අතර පසුව ඔබ ඉවරයි, පිටත යොමුව තවමත් මුල් වස්තුව වෙත යොමු වේ.
ඔබ වෙනස් කළ නොහැකි වස්තුවක් ක්‍රමයකට යොමු කළහොත්, ඔබට තවමත් බාහිර යොමු කිරීම නැවත කළ නොහැකි අතර, ඔබට වස්තුව විකෘති කිරීමට පවා නොහැකිය.
එය වඩාත් පැහැදිලි කිරීම සඳහා, අපි උදාහරණ කිහිපයක් බලමු.
ලැයිස්තුව - විකෘති වර්ගයකි
ක්‍රමයකට සම්මත කළ ලැයිස්තුව වෙනස් කිරීමට උත්සාහ කරමු:
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උල්.
මම හිතනවා මේකෙන් දේවල් ටිකක් පිරිසිදු වේවි කියලා.
සංස්කරණය කරන්න: ඩේවිඩ් මුලින් ඇසූ ප්‍රශ්නයට මෙය පිළිතුරු නොදෙන බව සටහන් කර ඇත, "සත්‍ය යොමු කිරීම මගින් විචල්යය සමත් කිරීමට මට යමක් කළ හැකිද?". අපි ඒ ගැන වැඩ කරමු.
අපි කොහොමද මේකෙන් බේරෙන්නේ?
@ ඇන්ඩ්‍රියාගේ පිළිතුරෙන් පෙන්නුම් කරන පරිදි, ඔබට නව අගය ආපසු ලබා දිය හැකිය. මෙය දේවල් සම්මත කර ගන්නා ආකාරය වෙනස් නොකරයි, නමුත් ඔබට අවශ්ය තොරතුරු ආපසු ලබා ගැනීමට ඉඩ දෙයි:
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])
මෙය ටිකක් කරදරකාරී බවක් පෙනුනත්.
