பைத்தானில் மாறி கடந்து செல்வதைப் புரிந்துகொள்வது: குறிப்பு எதிராக மதிப்பு

அறிமுகம்: பைதான் மாறி கடந்து செல்வதை ஆராய்தல்

பைத்தானில், செயல்பாடுகளுக்கு மாறிகள் அனுப்பப்படும் விதம் சில சமயங்களில் குழப்பத்தை ஏற்படுத்தலாம், குறிப்பாக பாஸ்-பை-ரெஃபரன்ஸ் மற்றும் பாஸ்-பை-வேல்யூ போன்ற கருத்துக்களைப் புரிந்துகொள்ள முயற்சிக்கும்போது. டெவலப்பர்கள் செயல்பாட்டிற்கு வெளியேயும் ஒரு செயல்பாட்டிற்குள் இருக்கும் மாறிக்கு மாற்றங்களை எதிர்பார்க்கும் சூழ்நிலைகளில் இந்த குழப்பம் அடிக்கடி முன்னிலைப்படுத்தப்படுகிறது.

இதை விளக்குவதற்கு, ஒரு முறையின் உள்ளே ஒரு மாறி மாற்றியமைக்கப்படும் வகுப்பைக் கவனியுங்கள். பைதான் மாறி கடந்து செல்வதை எவ்வாறு கையாளுகிறது என்பதன் காரணமாக எதிர்பார்க்கப்படும் விளைவு எப்போதும் உண்மையான முடிவுடன் பொருந்தாது. இந்தக் கட்டுரை இந்த நடத்தையின் பின்னால் உள்ள இயக்கவியலை ஆராய்கிறது மற்றும் பைத்தானில் பாஸ்-பை-ரெஃபரன்ஸ் விளைவுகளை அடைவது பற்றிய நுண்ணறிவுகளை வழங்குகிறது.

கட்டளை	விளக்கம்
self.variable = ['Original']	ஒற்றை சரம் உறுப்புடன் மாற்றக்கூடிய பட்டியலைத் துவக்குகிறது.
var[0] = 'Changed'	முறைக்கு அனுப்பப்பட்ட பட்டியலின் முதல் உறுப்பை மாற்றுகிறது.
class Wrapper:	ஒரு மதிப்பை இணைக்க ஒரு வகுப்பை வரையறுக்கிறது, இது பாஸ்-பை-ரெஃபரன்ஸ் போன்ற நடத்தையை அனுமதிக்கிறது.
self.value = value	ரேப்பர் வகுப்பிற்குள் மூடப்பட்ட மதிப்பை துவக்குகிறது.
var.value = 'Changed'	முறைக்கு அனுப்பப்பட்ட ரேப்பர் நிகழ்வின் மதிப்பு பண்புக்கூறை மாற்றியமைக்கிறது.
self.variable = {'key': 'Original'}	ஒற்றை விசை-மதிப்பு ஜோடியுடன் மாறக்கூடிய அகராதியைத் துவக்குகிறது.
var['key'] = 'Changed'	முறைக்கு அனுப்பப்பட்ட அகராதியில் உள்ள விசையுடன் தொடர்புடைய மதிப்பை மாற்றுகிறது.

பைத்தானில் பாஸ்-பை-ரெஃபரன்ஸ் செயல்படுத்துதல்

பைத்தானில் பாஸ்-பை-ரெஃபரன்ஸ் விளைவை அடைய முதல் ஸ்கிரிப்ட் மாற்றக்கூடிய பட்டியலைப் பயன்படுத்துகிறது. வகுப்பறையில் , மாறி ஒற்றை சரம் உறுப்பு 'அசல்' கொண்ட பட்டியலாக துவக்கப்பட்டது. முறை அழைக்கப்படுகிறது, இந்த பட்டியலை முறைக்கு அனுப்புகிறது. முறையின் உள்ளே, கட்டளை var[0] = 'Changed' பட்டியலின் முதல் உறுப்பை மாற்றியமைக்கிறது. பட்டியல்கள் மாறக்கூடியவை என்பதால், இந்த மாற்றம் முறைக்கு வெளியே பிரதிபலிக்கிறது, இதன் விளைவாக 'மாற்றப்பட்டது' வெளியீடு ஏற்படுகிறது. இந்த ஸ்கிரிப்ட் பட்டியல்கள் போன்ற மாறக்கூடிய வகைகளைப் பயன்படுத்துவது எப்படி பாஸ்-பை-ரெஃபரன்ஸ் நடத்தையை உருவகப்படுத்துகிறது என்பதை நிரூபிக்கிறது.

இரண்டாவது ஸ்கிரிப்ட் அறிமுகப்படுத்துகிறது ஒரு மதிப்பை இணைக்கும் வர்க்கம், பாஸ்-பை-குறிப்பு போன்ற செயல்பாட்டை அனுமதிக்கிறது. இல் வர்க்கம், மாறி ஒரு உதாரணத்துடன் துவக்கப்படுகிறது Wrapper 'அசல்' கொண்டுள்ளது. முறை அழைக்கப்படுகிறது, கடந்து உதாரணம். முறையின் உள்ளே, கட்டளை மாற்றியமைக்கிறது value பண்பு உதாரணம். இந்த மாற்றம் முறைக்கு வெளியே பிரதிபலிக்கிறது, இதன் விளைவாக 'மாற்றப்பட்டது' வெளியீடு. இந்த அணுகுமுறை, தனிப்பயன் ரேப்பர் வகுப்பை எவ்வாறு உருவாக்குவது என்பதைக் காட்டுகிறது.

மாறக்கூடிய நிலை கடந்து செல்ல அகராதிகளைப் பயன்படுத்துதல்

மூன்றாவது ஸ்கிரிப்ட் பாஸ்-பை-ரெஃபரன்ஸ் விளைவை அடைய அகராதியைப் பயன்படுத்துகிறது. இல் வர்க்கம், மாறி ஒற்றை விசை-மதிப்பு ஜோடியுடன் ஒரு அகராதியாக துவக்கப்பட்டது {'key': 'Original'}. முறை அழைக்கப்படுகிறது, இந்த அகராதியை முறைக்கு அனுப்புகிறது. முறையின் உள்ளே, கட்டளை var['key'] = 'Changed' அகராதியில் உள்ள விசையுடன் தொடர்புடைய மதிப்பை மாற்றியமைக்கிறது. அகராதிகள் மாறக்கூடியவை என்பதால், இந்த மாற்றம் முறைக்கு வெளியே பிரதிபலிக்கிறது, இதன் விளைவாக 'மாற்றப்பட்டது' வெளியீடு ஏற்படுகிறது. இந்த ஸ்கிரிப்ட், அகராதிகள் போன்ற மாறக்கூடிய வகைகளைப் பயன்படுத்துவது எவ்வாறு பாஸ்-பை-ரெஃபரன்ஸ் நடத்தையை உருவகப்படுத்துகிறது என்பதை எடுத்துக்காட்டுகிறது.

ஒட்டுமொத்தமாக, இந்த எடுத்துக்காட்டுகள் பைத்தானில் பாஸ்-பை-குறிப்பை உருவகப்படுத்துவதற்கான வெவ்வேறு அணுகுமுறைகளை விளக்குகின்றன. பட்டியல்கள் மற்றும் அகராதிகள் போன்ற மாறக்கூடிய வகைகளைப் பயன்படுத்துவதன் மூலம் அல்லது தனிப்பயன் ரேப்பர் வகுப்பைச் செயல்படுத்துவதன் மூலம், ஒரு செயல்பாட்டிற்குள் ஒரு மாறியின் மாற்றங்கள் செயல்பாட்டிற்கு வெளியே பிரதிபலிக்கும் போது விரும்பிய விளைவை அடைய முடியும். இந்த நுட்பங்களைப் புரிந்துகொள்வது டெவலப்பர்கள் தங்கள் பைதான் நிரல்களுக்குள் மாறிகளை மிகவும் திறம்பட கையாள விரும்பும்.

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

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

pbr = PassByReference()

class Wrapper:
    def __init__(self, value):
        self.value = value

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

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

pbr = PassByReference()

class PassByReference:
    def __init__(self):
        self.variable = {'key': 'Original'}
        self.change(self.variable)
        print(self.variable['key'])

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

pbr = PassByReference()

பைத்தானின் மாறி கையாளும் வழிமுறைகளைப் புரிந்துகொள்வது

பைத்தானில், மாறி கடந்து செல்லும் கருத்து சிக்கலானதாக இருக்கலாம், குறிப்பாக மாறக்கூடிய மற்றும் மாறாத பொருள்களை வேறுபடுத்தும் போது. பட்டியல்கள் மற்றும் அகராதிகள் போன்ற மாறக்கூடிய பொருள்கள் இடத்தில் மாற்றப்படலாம், அதாவது நீங்கள் ஒரு செயல்பாட்டிற்கு மாறக்கூடிய பொருளை அனுப்பினால், செயல்பாட்டிற்குள் செய்யப்படும் எந்த மாற்றங்களும் செயல்பாட்டிற்கு வெளியே உள்ள அசல் பொருளைப் பாதிக்கும். மறுபுறம், சரங்கள் மற்றும் டூப்பிள்கள் போன்ற மாறாத பொருள்களை இடத்தில் மாற்ற முடியாது. எனவே, நீங்கள் ஒரு செயல்பாட்டிற்கு ஒரு மாறாத பொருளை அனுப்பும் போது, ​​செயல்பாட்டிற்குள் ஏதேனும் மாற்றங்கள் ஒரு புதிய பொருளை உருவாக்கி, அசல் பொருளை மாற்றாமல் விட்டுவிடும்.

பைத்தானில் மாறி கையாளுதலின் மற்றொரு அம்சம் குறிப்புகள் எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வது. நீங்கள் மற்றொரு மாறிக்கு ஒரு மாறியை ஒதுக்கும்போது, ​​நீங்கள் உண்மையில் பொருளுக்கு ஒரு குறிப்பை ஒதுக்குகிறீர்கள், பொருளையே நகலெடுக்கவில்லை. பொருள் மாறக்கூடியதாக இருந்தால், அதை ஏதேனும் மாறி மூலம் மாற்றினால், மாற்றங்கள் எல்லா குறிப்புகளிலும் பிரதிபலிக்கும். மாற்றக்கூடிய வகைகள் அல்லது தனிப்பயன் வகுப்புகளைப் பயன்படுத்துவதன் மூலம், குறிப்பைப் பிரதிபலிக்கும் வகையில் இந்த நடத்தையைப் பயன்படுத்தலாம். கூடுதலாக, உள்ளமை செயல்பாடுகளுக்குள் உலகளாவிய மற்றும் உள்ளூர் அல்லாத மாறிகளை பைத்தானின் கையாளுதல் மாறி நோக்கம் மற்றும் மாற்றத்தை நிர்வகிக்க மற்றொரு வழியை வழங்குகிறது.

1. Python pass-by-value அல்லது pass-by-reference?
2. பைதான் "பாஸ்-பை-ஆப்ஜெக்ட்-ரெஃபரன்ஸ்" என்று அழைக்கப்படும் ஒரு பொறிமுறையைப் பயன்படுத்துகிறது, அங்கு பொருள்களைப் பற்றிய குறிப்புகள் அனுப்பப்படுகின்றன, பொருள்களே அல்ல.
3. ஒரு செயல்பாட்டிற்கு அனுப்பப்படும் போது எனது சரம் ஏன் மாறாது?
4. பைத்தானில் சரங்கள் மாறாதவை, எனவே ஒரு செயல்பாட்டிற்குள் எந்த மாற்றமும் அசலை மாற்றுவதை விட புதிய சரத்தை உருவாக்குகிறது.
5. மாறாத வகைகளுடன் நான் எவ்வாறு பாஸ்-பை-குறிப்பை உருவகப்படுத்துவது?
6. மாறாத வகையைப் பிடித்து, அதற்குப் பதிலாகப் கன்டெய்னரை அனுப்ப, பட்டியல் அல்லது அகராதி போன்ற மாறக்கூடிய கொள்கலனைப் பயன்படுத்தவும்.
7. ஒரு செயல்பாட்டிற்குள் ஒரு மாறியை நான் மீண்டும் ஒதுக்கும்போது என்ன நடக்கும்?
8. ஒரு செயல்பாட்டிற்குள் ஒரு மாறியை மறுஒதுக்கீடு செய்வது உள்ளூர் குறிப்பை மாற்றுகிறது, செயல்பாட்டிற்கு வெளியே உள்ள அசல் மாறி அல்ல.
9. ஒரு செயல்பாட்டிற்குள் உலகளாவிய மாறியை மாற்ற முடியுமா?
10. ஆம், ஐப் பயன்படுத்தி மாறியை உலகளாவியதாக அறிவிப்பதன் மூலம் முக்கிய வார்த்தை.
11. என்ன முக்கிய வார்த்தை பயன்படுத்தப்பட்டது?
12. தி முக்கிய வார்த்தையானது, உலகளாவியதாக இல்லாத, அருகில் உள்ள உள்ளடக்கத்தில் மாறிகளை மாற்ற உங்களை அனுமதிக்கிறது.
13. செயல்பாடுகளுக்கு அனுப்பப்படும் போது அகராதிகள் எவ்வாறு செயல்படுகின்றன?
14. அகராதிகள், மாறக்கூடியவையாக இருப்பதால், அசல் பொருளில் உள்ள செயல்பாடுகளில் செய்யப்பட்ட மாற்றங்களை பிரதிபலிக்கின்றன.
15. பைத்தானில் குறிப்பு மூலம் தனிப்பயன் பொருளை அனுப்ப முடியுமா?
16. ஆம், தனிப்பயன் பொருள்களைக் கடந்து செல்வது மாறக்கூடிய வகைகளைப் போன்றே செயல்படுகிறது.
17. ரேப்பர் கிளாஸ் என்றால் என்ன, மாறி பாஸிங்கிற்கு இது எப்படி உதவுகிறது?
18. ஒரு ரேப்பர் வகுப்பு ஒரு மதிப்பை இணைக்கிறது, இல்லையெனில் மாறாத வகைக்கு மாறக்கூடிய குறிப்பை வழங்குகிறது.

பைதான் மாறி கடந்து செல்லும் நுண்ணறிவு முடிவடைகிறது

பைதான் மாறி பாஸிங்கை எவ்வாறு கையாளுகிறது என்பதைப் புரிந்துகொள்வது பயனுள்ள நிரலாக்கத்திற்கு முக்கியமானது. மாறக்கூடிய பொருள்கள் மற்றும் தனிப்பயன் வகுப்புகளை மேம்படுத்துவதன் மூலம், டெவலப்பர்கள் பாஸ்-பை-குறிப்பை உருவகப்படுத்தலாம், இது மாறிகளை நேரடியாக மாற்றியமைக்க செயல்பாடுகளை அனுமதிக்கிறது. இந்த அறிவு மிகவும் திறமையான மற்றும் யூகிக்கக்கூடிய குறியீட்டை எழுத உதவுகிறது, பைதான் நிரல்களுக்குள் மாறி நோக்கம் மற்றும் மாற்றத்தை நிர்வகிக்கும் திறனை மேம்படுத்துகிறது. இந்த நுட்பங்களைச் செயல்படுத்துவது, விரும்பிய மாற்றங்கள் செயல்பாட்டு எல்லைகளில் பிரதிபலிக்கப்படுவதை உறுதி செய்கிறது.