நோக்கெல்லையைப் (scope) புரிந்துகொள்ளுங்கள்

Python-இல் function தனிமைப்படுத்தலின் அடிப்படைக் கட்டுமானத் தொகுதிகள் உள்ளக மாறிகள் (local variables) ஆகும் — அவற்றை அடையாளம் காண்பதே கணிக்கக்கூடிய, மீண்டும் பயன்படுத்தக்கூடிய function-களை எழுதுவதற்கான அடித்தளம்.

அறிமுகம்

நீங்கள் ஒரு function எழுதி அதன் உள்ளே ஒரு பெயரைக் குறிப்பிடும்போது, அந்தப் பெயர் local, enclosing, global அல்லது built-in என்பதில் எது என்று Python முடிவு செய்கிறது — அது local ஆக இருந்தால், function-க்கு வெளியிலிருந்து அதை நீங்கள் அணுக முடியாது. ஒரு function திரும்பிய பிறகு குழப்பமான NameError-ஐ நீங்கள் எப்போதாவது உற்றுப் பார்த்திருந்தால், அல்லது "பகிரப்பட்ட" நிலை போலத் தோன்றியதன் மூலம் இரண்டு test case-கள் ஒன்றையொன்று சிதைப்பதைப் பார்த்திருந்தால், அதன் மூல காரணம் கிட்டத்தட்ட எப்போதும் local scope-ஐத் தவறாகப் படித்ததுதான். இந்தப் பாடத்தின் முடிவில், ஒரு function-இல் எந்த மாறிகள் local என்பதை அடையாளம் காணவும், ஒவ்வொரு அழைப்பும் ஏன் தனக்கென ஒரு புதிய நகலைப் பெறுகிறது என்பதை விளக்கவும், அழைப்பவர்கள் தொடர்ந்து பயன்படுத்த முடியும்படி உங்களுக்குத் தேவையான தரவை return செய்யவும் உங்களால் முடியும்.

முக்கிய சொற்கள்

• local variable — ஒரு function உடலின் உள்ளே (assignment மூலமாகவோ அல்லது parameter ஆகவோ) உருவாக்கப்பட்ட, அந்த அழைப்பு இயங்கும்போது மட்டுமே இருக்கும் ஒரு பெயர். local-களை அடையாளம் காண்பது, function திரும்பிய கணத்தில் எந்தப் பெயர்கள் மறைந்துவிடும் என்பதை உங்களுக்குச் சொல்கிறது.
• scope — ஒரு பெயர் தெரியும் code-இன் பகுதி. local scope என்பது மிகச் சிறிய அலகு; print(x) எதை அணுக முடியும், எதை அணுக முடியாது என்பதை நீங்கள் கணிப்பது இதைப் புரிந்துகொள்வதன் மூலமே.
• NameError — அணுகக்கூடிய எந்த scope-இலும் பிணைக்கப்படாத ஒரு பெயரை நீங்கள் குறிப்பிடும்போது Python எழுப்பும் exception. local-variable தவறுகள் runtime-இல் கிட்டத்தட்ட எப்போதும் இப்படித்தான் வெளிப்படுகின்றன.
• call frame — ஒரு function இயங்கும் ஒவ்வொரு முறையும் Python உருவாக்கும் புதிய செயலாக்கச் சூழல். ஒவ்வொரு frame-ும் function-இன் local மாறிகளின் தனக்கென ஒரு நகலை வைத்திருக்கிறது; இதனால்தான் recursive மற்றும் மீண்டும் மீண்டும் நிகழும் அழைப்புகள் ஒன்றையொன்று சிதைப்பதில்லை.
• return மதிப்பு — ஒரு function தன்னை அழைத்தவருக்குத் திருப்பித் தரும் object; அதன் call frame அழிக்கப்பட்ட பிறகும் local தரவு உயிர்வாழ ஒரே வழி இதுதான்.

கருத்துகள்

Python ஒவ்வொரு பெயர்க் குறிப்பையும் LEGB விதியைப் பயன்படுத்தித் தீர்க்கிறது: முதலில் Local, பிறகு Enclosing, பிறகு Global, பிறகு Built-in. ஒரு function-இன் உள்ளே பிணைக்கப்பட்ட கணத்தில் — assignment மூலமாக, parameter பட்டியலில் தோன்றுவதன் மூலமாக, அல்லது for, with அல்லது except வழியாக அறிமுகப்படுத்தப்படுவதன் மூலமாக — ஒரு பெயர் local ஆகிறது.

ஒரு மாறியை local ஆக்குவது எது

ஒரு function-இன் உள்ளே வரையறுக்கப்பட்ட மாறிகள் அந்த function-க்கு local ஆகும். அவை function இயங்கும்போது மட்டுமே இருக்கின்றன; வெளியிலிருந்து அணுக முடியாது. வெளியிலிருந்து அவற்றைப் படிக்க முயற்சிப்பது NameError-ஐ எழுப்புகிறது. அழைப்புக்குப் பிறகும் ஒரு local மதிப்பை உயிருடன் வைத்திருக்க ஒரே வழி அதை return செய்வதுதான் (Code Walkthrough பார்க்கவும்).

ஒவ்வொரு அழைப்பும் தனக்கென ஒரு frame-ஐப் பெறுகிறது

ஒவ்வொரு அழைப்பும் தனக்கென local-களின் தொகுப்புடன் ஒரு புதிய call frame-ஐ உருவாக்குகிறது. ஒரே function-க்கான இரண்டு அழைப்புகள் — அடுத்தடுத்து நிகழ்ந்தாலும் — மாறிகளைப் பகிர்வதில்லை. இதுதான் function-களைப் பாதுகாப்பாக மீண்டும் பயன்படுத்தக்கூடியதாக ஆக்குகிறது: ஒரு அழைப்பு மற்றொன்றின் நிலையைச் சிதைக்க முடியாது.

Return செய்வதே தப்பிக்கும் வழி

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

Code Walkthrough

கீழே உள்ள snippet மூன்று கருத்துகளையும் ஒரே நேரத்தில் விளக்குகிறது: total, count மற்றும் average ஆகியவை calculate_total-க்கு local; add_to_list-க்கான ஒவ்வொரு அழைப்பும் ஒரு சுயாதீன frame-ஐ உருவாக்குகிறது என்பதை local_list காட்டுகிறது; மேலும் அழைப்பவர்கள் தரவைத் தக்கவைக்க முடியும்படி இரண்டு function-களும் தங்கள் local-களை return செய்கின்றன.

Code snippetpython
1def calculate_total(items):
2    """Locals total, count, average exist only during this call."""
3    total = 0
4    count = 0
5    for item in items:
6        total += item
7        count += 1
8    average = total / count if count > 0 else 0
9    return {"total": total, "count": count, "average": average}
10
11def add_to_list(item, initial_value=0):
12    """Each call gets a fresh local_list — no shared state."""
13    local_list = []
14    local_list.append(initial_value)
15    local_list.append(item)
16    return local_list
17
18result = calculate_total([10, 20, 30])
19print(result)              # {'total': 60, 'count': 3, 'average': 20.0}
20
21# print(total)             # NameError — total is local to calculate_total
22
23print(add_to_list("A"))    # [0, 'A']
24print(add_to_list("B"))    # [0, 'B']
25print(add_to_list("C", 100))  # [100, 'C']

• calculate_total — total, count மற்றும் average ஆகியவை உடலின் உள்ளே assignment மூலம் பிணைக்கப்படுகின்றன, எனவே அவை local; return செய்யப்படும் dict மட்டுமே அழைப்பவர் அவற்றின் மதிப்புகளைக் காண ஒரே வழி.
• add_to_list — item மற்றும் initial_value ஆகியவை parameter-கள் என்பதால் local; local_list உடலின் உள்ளே assign செய்யப்படுவதால் local. ஒவ்வொரு அழைப்பும் local_list-ஐ முதலிலிருந்து மீண்டும் உருவாக்குகிறது.
• comment செய்யப்பட்ட print(total) — அதை uncomment செய்தால் NameError: name 'total' is not defined எழுப்பப்படுகிறது; ஒரு local-ஐ அதன் scope-க்கு வெளியிலிருந்து படிக்க முயன்றீர்கள் என்பதற்கான runtime சமிக்ஞை இதுதான்.

script-ஐ இயக்கும்போது {'total': 60, 'count': 3, 'average': 20.0} அச்சிடப்பட்டு, அதைத் தொடர்ந்து மூன்று சுயாதீன list-கள் அச்சிடப்பட்டால், மேலும் print(total)-ஐ uncomment செய்தால் NameError எழும் என்பதை — இயக்குவதற்கு முன்பே — உங்களால் கணிக்க முடிந்தால், அது வேலை செய்கிறது என்று நீங்கள் அறிவீர்கள்.

-க்கான நடைமுறையில்

walkthrough-இன் அடிப்படையில், உள்ளக மாறிகளை அடையாளம் காண்பது உங்கள் அன்றாட வேலையில் எப்படி வெளிப்படுகிறது என்பது இதோ.

செய்ய வேண்டியவை மற்றும் செய்யக்கூடாதவை

செய்ய வேண்டியவை

1. உங்களுக்குத் தேவையான local-களை return செய்யுங்கள் — call frame அழிக்கப்பட்டவுடன் தரவு உயிர்வாழ ஒரே வழி return மட்டுமே.
2. ஒவ்வொரு அழைப்பையும் சுயாதீனமானதாகக் கருதுங்கள் — அழைப்புகளுக்கு இடையே எதுவும் கடத்தப்படாது என்று கொள்ளுங்கள்; கடத்தப்பட வேண்டுமென்றால், அதை உள்ளே அனுப்புங்கள் அல்லது return மூலம் வெளியே கொண்டு வாருங்கள்.
3. NameError-ஐ ஒரு scope துப்பாகப் படியுங்கள் — ஒன்று எழும்போது, அந்தப் பெயர் நீங்கள் ஏற்கனவே விட்டு வெளியேறிய ஒரு function-இன் உள்ளே மட்டுமே பிணைக்கப்பட்டதா என்று முதலில் கேளுங்கள்.

செய்யக்கூடாதவை

1. ஒரு local-ஐ function-களுக்கு இடையே "பகிர" global-ஐ நாடாதீர்கள் — அது தொடர்பில்லாத அழைப்பவர்களை இணைத்து, local-கள் உங்களுக்குத் தரும் ஒவ்வொரு அழைப்புக்கான சுயாதீனத்தை அழித்துவிடும்.
2. இரண்டு அழைப்புகள் நிலையைப் பகிர்கின்றன என்று கருதாதீர்கள் — ஒவ்வொரு அழைப்பும் தனக்கென ஒரு frame-ஐப் பெறுகிறது, எனவே முந்தைய அழைப்பின் local-கள் அங்கே இருக்கும் என்று நம்பாதீர்கள்.
3. ஒரு function-இன் local-களை வெளியிலிருந்து படிக்க முயற்சிக்காதீர்கள் — அழைப்பு திரும்பிய பிறகு அவை இருப்பதில்லை; அதற்குப் பதிலாக உங்களுக்குத் தேவையானதை return செய்யும்படி மறுகட்டமைப்பு செய்யுங்கள்.