స్కోప్‌ను అర్థం చేసుకోండి

లోకల్ వేరియబుల్స్ అనేవి Pythonలో ఫంక్షన్ ఐసొలేషన్‌కు మూలభూత అంశాలు — వాటిని గుర్తించడం అంచనా వేయగల, పునర్వినియోగించదగిన ఫంక్షన్‌లను రాయడానికి పునాది.

పరిచయం

మీరు ఒక ఫంక్షన్ రాసి, దాని లోపల ఒక పేరును రిఫరెన్స్ చేసినప్పుడు, ఆ పేరు లోకలా, ఎన్‌క్లోజింగా, గ్లోబలా, లేదా బిల్ట్-ఇనా అనేది Python నిర్ణయిస్తుంది — అది లోకల్ అయితే, మీరు దాన్ని ఫంక్షన్ బయటి నుండి చేరుకోలేరు. ఒక ఫంక్షన్ రిటర్న్ అయిన తర్వాత గందరగోళంగా ఉన్న NameErrorను మీరు ఎప్పుడైనా చూసి ఉంటే, లేదా "షేర్డ్" అనిపించే స్టేట్ ద్వారా రెండు టెస్ట్ కేసులు ఒకదానికొకటి పాడుచేసుకోవడాన్ని గమనించి ఉంటే, మూల కారణం దాదాపు ఎప్పుడూ లోకల్ స్కోప్‌ను తప్పుగా చదవడమే. ఈ పాఠం చివరికి, ఒక ఫంక్షన్‌లో ఏ వేరియబుల్స్ లోకల్‌వో గుర్తించగలరు, ప్రతి కాల్‌కు దాని స్వంత తాజా కాపీ ఎందుకు వస్తుందో వివరించగలరు, మరియు కాలర్‌లు వాడుకోవడానికి వీలుగా మీకు కావలసిన డేటాను రిటర్న్ చేయగలరు.

కీలక పరిభాష

• local variable — ఒక ఫంక్షన్ బాడీ లోపల (అసైన్‌మెంట్ ద్వారా లేదా పారామీటర్‌గా) సృష్టించబడిన పేరు, అది ఆ కాల్ నడుస్తున్నప్పుడు మాత్రమే ఉంటుంది. లోకల్స్‌ను గుర్తించడం అనేది ఫంక్షన్ రిటర్న్ అయిన క్షణంలోనే ఏ పేర్లు అదృశ్యమవుతాయో చెబుతుంది.
• scope — ఒక పేరు కనిపించే కోడ్ ప్రాంతం. లోకల్ స్కోప్ అనేది అతిచిన్న యూనిట్; దీన్ని అర్థం చేసుకోవడమే print(x) దేన్ని చేరుకోగలదో, దేన్ని చేరుకోలేదో అంచనా వేయడానికి మార్గం.
• NameError — ఏ చేరుకోగల స్కోప్‌లోనూ బైండ్ కాని పేరును మీరు రిఫరెన్స్ చేసినప్పుడు Python విసిరే ఎక్సెప్షన్. లోకల్-వేరియబుల్ పొరపాట్లు దాదాపు ఎప్పుడూ రన్‌టైమ్‌లో ఇలాగే బయటపడతాయి.
• call frame — ఒక ఫంక్షన్ నడిచే ప్రతిసారీ Python సృష్టించే తాజా ఎగ్జిక్యూషన్ కాంటెక్స్ట్. ప్రతి ఫ్రేమ్ ఫంక్షన్ లోకల్ వేరియబుల్స్ యొక్క దాని స్వంత కాపీని కలిగి ఉంటుంది, అందుకే రికర్సివ్ మరియు పునరావృత కాల్స్ ఒకదానికొకటి పాడుచేసుకోవు.
• return value — ఒక ఫంక్షన్ తన కాలర్‌కు తిరిగి అప్పగించే ఆబ్జెక్ట్; కాల్ ఫ్రేమ్ నాశనమైన తర్వాత లోకల్ డేటా బతికి ఉండటానికి ఏకైక మార్గం.

భావనలు

Python ప్రతి పేరు రిఫరెన్స్‌ను LEGB నియమాన్ని ఉపయోగించి పరిష్కరిస్తుంది: మొదట Local, తర్వాత Enclosing, తర్వాత Global, తర్వాత Built-in. ఒక పేరు ఫంక్షన్ లోపల బైండ్ అయిన క్షణంలోనే లోకల్ అవుతుంది — అసైన్‌మెంట్ ద్వారా, పారామీటర్ లిస్ట్‌లో కనిపించడం ద్వారా, లేదా for, with, లేదా except ద్వారా ప్రవేశపెట్టబడటం ద్వారా.

ఒక వేరియబుల్‌ను లోకల్‌గా చేసేది ఏమిటి

ఒక ఫంక్షన్ లోపల నిర్వచించబడిన వేరియబుల్స్ ఆ ఫంక్షన్‌కు లోకల్. అవి ఫంక్షన్ నడుస్తున్నప్పుడు మాత్రమే ఉంటాయి మరియు బయటి నుండి యాక్సెస్ చేయలేము. వాటిని బయటి నుండి చదవడానికి ప్రయత్నిస్తే NameError వస్తుంది. కాల్ తర్వాత లోకల్ విలువను సజీవంగా ఉంచడానికి ఏకైక మార్గం దాన్ని రిటర్న్ చేయడమే (చూడండి Code Walkthrough).

ప్రతి కాల్‌కు దాని స్వంత ఫ్రేమ్ వస్తుంది

ప్రతి ఇన్వొకేషన్ దాని స్వంత లోకల్స్ సెట్‌తో ఒక తాజా call frameను సృష్టిస్తుంది. ఒకే ఫంక్షన్‌కు రెండు కాల్స్ — వరుసగా ఒకదాని వెనుక ఒకటి అయినా సరే — వేరియబుల్స్‌ను షేర్ చేయవు. ఇదే ఫంక్షన్‌లను సురక్షితంగా పునర్వినియోగించదగినవిగా చేస్తుంది: ఒక కాల్ మరొకదాని స్టేట్‌ను పాడుచేయలేదు.

రిటర్న్ చేయడమే బయటపడే మార్గం

లోకల్స్ ఫ్రేమ్‌తో పాటే చనిపోతాయి కాబట్టి, మీరు ఉంచుకోవాలనుకున్న ఏ విలువైనా return ద్వారానే బయటకు వెళ్ళాలి. ఒక ఫంక్షన్‌లో ఏ పేర్లు లోకల్‌వో గుర్తించడం, కాలర్ వాడుకోబోతున్నట్లయితే return స్టేట్‌మెంట్‌లో సరిగ్గా ఏవి కనిపించాలో మీకు చెబుతుంది.

కోడ్ వాక్‌త్రూ

కింది స్నిప్పెట్ మూడు భావనలను ఒకేసారి ప్రదర్శిస్తుంది: total, count, మరియు average అనేవి calculate_totalకు లోకల్; local_list అనేది add_to_listకు ప్రతి కాల్ ఒక స్వతంత్ర ఫ్రేమ్‌ను నిర్మిస్తుందని చూపిస్తుంది; మరియు కాలర్‌లు డేటాను ఉంచుకోవడానికి రెండు ఫంక్షన్‌లూ తమ లోకల్స్‌ను 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 అనేవి బాడీ లోపల అసైన్‌మెంట్ ద్వారా బైండ్ అయ్యాయి, కాబట్టి అవి లోకల్; రిటర్న్ చేయబడిన dict అనేది కాలర్ వాటి విలువలను చూడటానికి ఏకైక మార్గం.
• add_to_list — item మరియు initial_value పారామీటర్లు కాబట్టి లోకల్; local_list బాడీ లోపల అసైన్ చేయబడింది కాబట్టి లోకల్. ప్రతి కాల్ local_listను మొదటి నుండి మళ్ళీ నిర్మిస్తుంది.
• కామెంట్ చేయబడిన print(total) — దాన్ని అన్‌కామెంట్ చేస్తే NameError: name 'total' is not defined వస్తుంది, ఇది మీరు దాని స్కోప్ బయటి నుండి ఒక లోకల్‌ను చదవడానికి ప్రయత్నించారన్న రన్‌టైమ్ సంకేతం.

స్క్రిప్ట్‌ను రన్ చేసినప్పుడు అది {'total': 60, 'count': 3, 'average': 20.0} తర్వాత మూడు స్వతంత్ర లిస్ట్‌లను ప్రింట్ చేస్తే అది పనిచేస్తుందని మీకు తెలుస్తుంది, మరియు print(total)ను అన్‌కామెంట్ చేస్తే NameError వస్తుందని — రన్ చేయకముందే — మీరు అంచనా వేయగలరు.

కోసం ఆచరణలో

వాక్‌త్రూపై ఆధారపడి, లోకల్ వేరియబుల్స్‌ను గుర్తించడం మీ రోజువారీ పనిలో ఎలా కనిపిస్తుందో ఇక్కడ ఉంది.

చేయవలసినవి మరియు చేయకూడనివి

చేయవలసినవి

1. మీకు కావలసిన లోకల్స్‌ను రిటర్న్ చేయండి — కాల్ ఫ్రేమ్ నాశనమైన తర్వాత డేటా బతికి ఉండటానికి return ఏకైక మార్గం.
2. ప్రతి కాల్‌ను స్వతంత్రంగా పరిగణించండి — కాల్స్ మధ్య ఏమీ కొనసాగదని భావించండి; అది కొనసాగాలంటే, దాన్ని లోపలికి పంపండి లేదా return ద్వారా బయటకు తీసుకురండి.
3. NameErrorను స్కోప్ సూచనగా చదవండి — ఒకటి వచ్చినప్పుడు, మీరు ఇప్పటికే వదిలివచ్చిన ఒక ఫంక్షన్ లోపల మాత్రమే ఆ పేరు బైండ్ అయ్యిందా అని ముందుగా అడగండి.

చేయకూడనివి

1. ఫంక్షన్‌ల మధ్య ఒక లోకల్‌ను "షేర్" చేయడానికి global వైపు వెళ్ళకండి — ఇది సంబంధం లేని కాలర్‌లను జోడిస్తుంది మరియు లోకల్స్ ఇచ్చే ప్రతి-కాల్ స్వాతంత్ర్యాన్ని చెరిపేస్తుంది.
2. రెండు కాల్స్ స్టేట్‌ను షేర్ చేస్తాయని భావించకండి — ప్రతి ఇన్వొకేషన్ దాని స్వంత ఫ్రేమ్‌ను పొందుతుంది, కాబట్టి మునుపటి కాల్ యొక్క లోకల్స్ అక్కడ ఉంటాయని ఆధారపడకండి.
3. ఒక ఫంక్షన్ లోకల్స్‌ను బయటి నుండి చదవడానికి ప్రయత్నించకండి — కాల్ రిటర్న్ అయిన తర్వాత అవి ఉండవు; బదులుగా మీకు కావలసినదాన్ని రిటర్న్ చేసేలా పునర్నిర్మించండి.