ಸ್ಕೋಪ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ

ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು Python ನಲ್ಲಿ ಫಂಕ್ಷನ್ ಪ್ರತ್ಯೇಕತೆಯ ಮೂಲ ಘಟಕಗಳು — ಅವುಗಳನ್ನು ಗುರುತಿಸುವುದು ಊಹಿಸಬಹುದಾದ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬರೆಯುವುದರ ಅಡಿಪಾಯ.

ಪರಿಚಯ

ನೀವು ಒಂದು ಫಂಕ್ಷನ್ ಬರೆದು ಅದರೊಳಗೆ ಒಂದು ಹೆಸರನ್ನು ಉಲ್ಲೇಖಿಸಿದಾಗ, ಆ ಹೆಸರು local, enclosing, global ಅಥವಾ built-in ಆಗಿದೆಯೇ ಎಂದು Python ನಿರ್ಧರಿಸುತ್ತದೆ — ಮತ್ತು ಅದು local ಆಗಿದ್ದರೆ, ನೀವು ಫಂಕ್ಷನ್‌ನ ಹೊರಗಿನಿಂದ ಅದನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ. ಫಂಕ್ಷನ್ return ಆದ ನಂತರ ಗೊಂದಲಮಯ NameError ಅನ್ನು ನೀವು ಎಂದಾದರೂ ದಿಟ್ಟಿಸಿ ನೋಡಿದ್ದರೆ, ಅಥವಾ "ಹಂಚಿಕೊಂಡ" ಸ್ಥಿತಿಯಂತೆ ಕಾಣುತ್ತಿದ್ದ ಯಾವುದರ ಮೂಲಕವೋ ಎರಡು ಟೆಸ್ಟ್ ಕೇಸ್‌ಗಳು ಪರಸ್ಪರ ಹಾಳಾಗುವುದನ್ನು ನೋಡಿದ್ದರೆ, ಅದರ ಮೂಲ ಕಾರಣ ಬಹುತೇಕ ಯಾವಾಗಲೂ ಸ್ಥಳೀಯ ವ್ಯಾಪ್ತಿಯನ್ನು ತಪ್ಪಾಗಿ ಓದಿರುವುದೇ ಆಗಿರುತ್ತದೆ. ಈ ಪಾಠದ ಕೊನೆಯ ವೇಳೆಗೆ, ಒಂದು ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಯಾವ ವೇರಿಯಬಲ್‌ಗಳು ಸ್ಥಳೀಯ ಎಂದು ಗುರುತಿಸಲು, ಪ್ರತಿ ಕರೆಗೂ ತನ್ನದೇ ಆದ ಹೊಸ ಪ್ರತಿ ಏಕೆ ಸಿಗುತ್ತದೆ ಎಂದು ವಿವರಿಸಲು, ಮತ್ತು ಕರೆ ಮಾಡುವವರು ಬಳಸುತ್ತಲೇ ಇರಬಹುದಾದಂತೆ ನಿಮಗೆ ಬೇಕಾದ ಡೇಟಾವನ್ನು return ಮಾಡಲು ನೀವು ಸಮರ್ಥರಾಗುತ್ತೀರಿ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• local variable (ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್) — ಫಂಕ್ಷನ್ ದೇಹದೊಳಗೆ (ನಿಯೋಜನೆಯ ಮೂಲಕ ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ) ಸೃಷ್ಟಿಯಾದ ಹೆಸರು, ಅದು ಆ ಕರೆ ನಡೆಯುತ್ತಿರುವಾಗ ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತದೆ. ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಗುರುತಿಸುವುದರಿಂದ ಫಂಕ್ಷನ್ return ಆದ ಕ್ಷಣದಲ್ಲಿ ಯಾವ ಹೆಸರುಗಳು ಕಣ್ಮರೆಯಾಗುತ್ತವೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ.
• scope (ವ್ಯಾಪ್ತಿ) — ಒಂದು ಹೆಸರು ಗೋಚರಿಸುವ ಕೋಡ್‌ನ ಪ್ರದೇಶ. ಸ್ಥಳೀಯ ವ್ಯಾಪ್ತಿ ಅತ್ಯಂತ ಚಿಕ್ಕ ಘಟಕ; ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದಲೇ print(x) ಯಾವುದನ್ನು ತಲುಪಬಹುದು ಮತ್ತು ಯಾವುದನ್ನು ತಲುಪಲಾರದು ಎಂದು ನೀವು ಊಹಿಸಬಹುದು.
• NameError — ಯಾವುದೇ ತಲುಪಬಹುದಾದ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಬೈಂಡ್ ಆಗದ ಹೆಸರನ್ನು ನೀವು ಉಲ್ಲೇಖಿಸಿದಾಗ Python ಎಬ್ಬಿಸುವ exception. ಸ್ಥಳೀಯ-ವೇರಿಯಬಲ್ ತಪ್ಪುಗಳು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಬಹುತೇಕ ಯಾವಾಗಲೂ ಹೀಗೆಯೇ ಹೊರಹೊಮ್ಮುತ್ತವೆ.
• call frame (ಕರೆ ಫ್ರೇಮ್) — ಫಂಕ್ಷನ್ ರನ್ ಆಗುವ ಪ್ರತಿ ಬಾರಿಯೂ Python ಸೃಷ್ಟಿಸುವ ಹೊಸ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂದರ್ಭ. ಪ್ರತಿ ಫ್ರೇಮ್ ಫಂಕ್ಷನ್‌ನ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳ ತನ್ನದೇ ಆದ ಪ್ರತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಅದಕ್ಕಾಗಿಯೇ recursive ಮತ್ತು ಪುನರಾವರ್ತಿತ ಕರೆಗಳು ಪರಸ್ಪರ ಹಾಳುಮಾಡುವುದಿಲ್ಲ.
• return ಮೌಲ್ಯ — ಫಂಕ್ಷನ್ ತನ್ನ ಕರೆ ಮಾಡುವವರಿಗೆ ಹಿಂತಿರುಗಿಸುವ ವಸ್ತು; ಕರೆ ಫ್ರೇಮ್ ನಾಶವಾದ ನಂತರವೂ ಸ್ಥಳೀಯ ಡೇಟಾ ಉಳಿದುಕೊಳ್ಳುವ ಏಕೈಕ ಮಾರ್ಗ.

ಪರಿಕಲ್ಪನೆಗಳು

Python ಪ್ರತಿ ಹೆಸರಿನ ಉಲ್ಲೇಖವನ್ನು LEGB ನಿಯಮವನ್ನು ಬಳಸಿ ಪರಿಹರಿಸುತ್ತದೆ: ಮೊದಲು Local, ನಂತರ Enclosing, ನಂತರ Global, ನಂತರ Built-in. ಒಂದು ಹೆಸರು ಫಂಕ್ಷನ್‌ನೊಳಗೆ ಬೈಂಡ್ ಆದ ಕ್ಷಣದಲ್ಲಿ — ನಿಯೋಜನೆಯ ಮೂಲಕ, ಪ್ಯಾರಾಮೀಟರ್ ಪಟ್ಟಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಅಥವಾ for, with, ಅಥವಾ except ಮೂಲಕ ಪರಿಚಯಿಸಲ್ಪಡುವ ಮೂಲಕ — ಅದು ಸ್ಥಳೀಯವಾಗುತ್ತದೆ.

ಒಂದು ವೇರಿಯಬಲ್ ಅನ್ನು ಸ್ಥಳೀಯವನ್ನಾಗಿ ಮಾಡುವುದು ಯಾವುದು

ಫಂಕ್ಷನ್‌ನೊಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವೇರಿಯಬಲ್‌ಗಳು ಆ ಫಂಕ್ಷನ್‌ಗೆ ಸ್ಥಳೀಯವಾಗಿರುತ್ತವೆ. ಅವು ಫಂಕ್ಷನ್ ರನ್ ಆಗುತ್ತಿರುವಾಗ ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತವೆ ಮತ್ತು ಹೊರಗಿನಿಂದ ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಹೊರಗಿನಿಂದ ಅವುಗಳನ್ನು ಓದಲು ಪ್ರಯತ್ನಿಸಿದರೆ NameError ಬರುತ್ತದೆ. ಕರೆಯ ನಂತರವೂ ಸ್ಥಳೀಯ ಮೌಲ್ಯವನ್ನು ಜೀವಂತವಾಗಿಡುವ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ ಅದನ್ನು return ಮಾಡುವುದು (ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ ನೋಡಿ).

ಪ್ರತಿ ಕರೆಗೂ ತನ್ನದೇ ಆದ ಫ್ರೇಮ್ ಸಿಗುತ್ತದೆ

ಪ್ರತಿ ಆಹ್ವಾನವೂ ತನ್ನದೇ ಆದ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳ ಸೆಟ್‌ನೊಂದಿಗೆ ಹೊಸ ಕರೆ ಫ್ರೇಮ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಒಂದೇ ಫಂಕ್ಷನ್‌ಗೆ ಮಾಡಿದ ಎರಡು ಕರೆಗಳು — ಒಂದರ ಹಿಂದೆ ಒಂದು ಮಾಡಿದರೂ — ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಇದೇ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮರುಬಳಕೆ ಮಾಡುವಂತೆ ಮಾಡುತ್ತದೆ: ಒಂದು ಕರೆ ಇನ್ನೊಂದರ ಸ್ಥಿತಿಯನ್ನು ಹಾಳುಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.

Return ಮಾಡುವುದೇ ಹೊರದಾರಿ

ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು ಫ್ರೇಮ್‌ನೊಂದಿಗೆ ಸಾಯುವುದರಿಂದ, ನೀವು ಉಳಿಸಿಕೊಳ್ಳಲು ಬಯಸುವ ಯಾವುದೇ ಮೌಲ್ಯವು return ಮೂಲಕ ಹೊರಹೋಗಬೇಕು. ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಯಾವ ಹೆಸರುಗಳು ಸ್ಥಳೀಯ ಎಂದು ಗುರುತಿಸುವುದರಿಂದ, ಕರೆ ಮಾಡುವವರು ಬಳಸಬೇಕೆಂದಿದ್ದರೆ ಯಾವುವು ನಿಖರವಾಗಿ return ಹೇಳಿಕೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳಬೇಕು ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ಕೆಳಗಿನ ಸ್ನಿಪೆಟ್ ಮೂರೂ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ತೋರಿಸುತ್ತದೆ: total, count, ಮತ್ತು average ಗಳು calculate_total ಗೆ ಸ್ಥಳೀಯ; add_to_list ಗೆ ಮಾಡುವ ಪ್ರತಿ ಕರೆಯೂ ಸ್ವತಂತ್ರ ಫ್ರೇಮ್ ನಿರ್ಮಿಸುತ್ತದೆ ಎಂದು local_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 ಗಳು ದೇಹದೊಳಗೆ ನಿಯೋಜನೆಯ ಮೂಲಕ ಬೈಂಡ್ ಆಗಿವೆ, ಹಾಗಾಗಿ ಅವು ಸ್ಥಳೀಯ; return ಆದ 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 ಮಾಡಿ — ಕರೆ ಫ್ರೇಮ್ ನಾಶವಾದ ನಂತರ ಡೇಟಾ ಉಳಿದುಕೊಳ್ಳುವ ಏಕೈಕ ಮಾರ್ಗ return.
2. ಪ್ರತಿ ಕರೆಯನ್ನೂ ಸ್ವತಂತ್ರವೆಂದು ಪರಿಗಣಿಸಿ — ಕರೆಗಳ ನಡುವೆ ಏನೂ ಮುಂದುವರಿಯುವುದಿಲ್ಲ ಎಂದು ಭಾವಿಸಿ; ಮುಂದುವರಿಯಲೇಬೇಕಾದರೆ, ಅದನ್ನು ಒಳಗೆ ರವಾನಿಸಿ ಅಥವಾ return ಮೂಲಕ ಹೊರತನ್ನಿ.
3. NameError ಅನ್ನು ವ್ಯಾಪ್ತಿಯ ಸುಳಿವಾಗಿ ಓದಿ — ಅದು ಬಂದಾಗ, ಆ ಹೆಸರು ನೀವು ಆಗಲೇ ಹೊರಬಂದಿರುವ ಫಂಕ್ಷನ್‌ನೊಳಗೆ ಮಾತ್ರ ಬೈಂಡ್ ಆಗಿತ್ತೇ ಎಂದು ಮೊದಲು ಕೇಳಿಕೊಳ್ಳಿ.

ಮಾಡಬಾರದವು

1. ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಅನ್ನು ಫಂಕ್ಷನ್‌ಗಳ ನಡುವೆ "ಹಂಚಿಕೊಳ್ಳಲು" global ಬಳಸಬೇಡಿ — ಅದು ಸಂಬಂಧವಿಲ್ಲದ ಕರೆ ಮಾಡುವವರನ್ನು ಬೆಸೆಯುತ್ತದೆ ಮತ್ತು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು ನಿಮಗೆ ನೀಡುವ ಪ್ರತಿ-ಕರೆ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ಅಳಿಸಿಹಾಕುತ್ತದೆ.
2. ಎರಡು ಕರೆಗಳು ಸ್ಥಿತಿಯನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ ಎಂದು ಭಾವಿಸಬೇಡಿ — ಪ್ರತಿ ಆಹ್ವಾನಕ್ಕೂ ತನ್ನದೇ ಆದ ಫ್ರೇಮ್ ಸಿಗುತ್ತದೆ, ಹಾಗಾಗಿ ಹಿಂದಿನ ಕರೆಯ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು ಅಲ್ಲಿರುತ್ತವೆ ಎಂದು ಅವಲಂಬಿಸಬೇಡಿ.
3. ಫಂಕ್ಷನ್‌ನ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಹೊರಗಿನಿಂದ ಓದಲು ಪ್ರಯತ್ನಿಸಬೇಡಿ — ಕರೆ return ಆದ ನಂತರ ಅವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವುದಿಲ್ಲ; ಬದಲಿಗೆ ನಿಮಗೆ ಬೇಕಾದುದನ್ನು return ಮಾಡುವಂತೆ ಮರುರಚಿಸಿ.