Free lesson · GenAI Agent Engineering
நோக்கெல்லையைப் (scope) புரிந்துகொள்ளுங்கள்
Course: Python Essentials for Agent Builders · Chapter 5 · Functions
Free to read — no subscription required.
Goal
Python-இல் variable scope-ஐ நீங்கள் புரிந்துகொள்வீர்கள். functions-க்குள் இருக்கும் local variables-ஐ அடையாளம் காணவும், global keyword-ஐ எப்போது பயன்படுத்த வேண்டும் என்பதைப் புரிந்துகொள்ளவும், scope தொடர்பான பொதுவான bugs-ஐத் தவிர்க்கவும் கற்றுக்கொள்வீர்கள்.
Lesson walkthrough
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 கூற்றில் எவை இடம்பெற வேண்டும் என்பதைத் துல்லியமாக உங்களுக்குச் சொல்கிறது.
கீழே உள்ள 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-இன் அடிப்படையில், உள்ளக மாறிகளை அடையாளம் காண்பது உங்கள் அன்றாட வேலையில் எப்படி வெளிப்படுகிறது என்பது இதோ.
செய்ய வேண்டியவை
- உங்களுக்குத் தேவையான local-களை return செய்யுங்கள் — call frame அழிக்கப்பட்டவுடன் தரவு உயிர்வாழ ஒரே வழி
returnமட்டுமே. - ஒவ்வொரு அழைப்பையும் சுயாதீனமானதாகக் கருதுங்கள் — அழைப்புகளுக்கு இடையே எதுவும் கடத்தப்படாது என்று கொள்ளுங்கள்; கடத்தப்பட வேண்டுமென்றால், அதை உள்ளே அனுப்புங்கள் அல்லது
returnமூலம் வெளியே கொண்டு வாருங்கள். NameError-ஐ ஒரு scope துப்பாகப் படியுங்கள் — ஒன்று எழும்போது, அந்தப் பெயர் நீங்கள் ஏற்கனவே விட்டு வெளியேறிய ஒரு function-இன் உள்ளே மட்டுமே பிணைக்கப்பட்டதா என்று முதலில் கேளுங்கள்.
செய்யக்கூடாதவை
- ஒரு local-ஐ function-களுக்கு இடையே "பகிர"
global-ஐ நாடாதீர்கள் — அது தொடர்பில்லாத அழைப்பவர்களை இணைத்து, local-கள் உங்களுக்குத் தரும் ஒவ்வொரு அழைப்புக்கான சுயாதீனத்தை அழித்துவிடும். - இரண்டு அழைப்புகள் நிலையைப் பகிர்கின்றன என்று கருதாதீர்கள் — ஒவ்வொரு அழைப்பும் தனக்கென ஒரு frame-ஐப் பெறுகிறது, எனவே முந்தைய அழைப்பின் local-கள் அங்கே இருக்கும் என்று நம்பாதீர்கள்.
- ஒரு function-இன் local-களை வெளியிலிருந்து படிக்க முயற்சிக்காதீர்கள் — அழைப்பு திரும்பிய பிறகு அவை இருப்பதில்லை; அதற்குப் பதிலாக உங்களுக்குத் தேவையானதை return செய்யும்படி மறுகட்டமைப்பு செய்யுங்கள்.