સ્કોપ સમજો

લોકલ વેરિએબલ્સ 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 ઉઠાવે છે. કૉલ પછી લોકલ વેલ્યુને જીવંત રાખવાની એકમાત્ર રીત તેને રિટર્ન કરવી છે (જુઓ કોડ વૉકથ્રુ).

દરેક કૉલને પોતાની ફ્રેમ મળે છે

દરેક ઇન્વોકેશન પોતાના લોકલ્સના સેટ સાથે એક તાજી કૉલ ફ્રેમ બનાવે છે. એક જ ફંક્શનના બે કૉલ્સ — ભલે એક પછી એક તરત જ હોય — વેરિએબલ્સ શેર કરતા નથી. આ જ ફંક્શન્સને સુરક્ષિત રીતે પુનઃઉપયોગી બનાવે છે: એક કૉલ બીજાની સ્ટેટને બગાડી શકતો નથી.

રિટર્ન કરવું એ બહાર નીકળવાનો માર્ગ છે

કારણ કે લોકલ્સ ફ્રેમ સાથે નષ્ટ થાય છે, તમે જે પણ વેલ્યુ રાખવા ઇચ્છો તે 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. ફંક્શનના લોકલ્સને બહારથી વાંચવાનો પ્રયાસ ન કરો — કૉલ રિટર્ન થયા પછી તેઓ અસ્તિત્વમાં નથી; તેના બદલે તમને જે જરૂરી છે તે રિટર્ન કરવા માટે પુનર્રચના કરો.