ವೇರಿಯೇಬಲ್ ಸ್ಕೋಪ್ ಮತ್ತು ಲೈಫ್‌ಟೈಮ್ (Variable Scope and Lifetime)

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಸ್ಕೋಪ್ (Scope) ಎಂದರೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು (access) ಸಾಧ್ಯವಿರುವ ಪ್ರೋಗ್ರಾಮ್‌ನ ಪ್ರದೇಶ. ಲೈಫ್‌ಟೈಮ್ (Lifetime) ಎಂದರೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಮೆಮೊರಿಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅವಧಿ.

ಈ ಪರಿಕಲ್ಪನೆಗಳು ವೇರಿಯೇಬಲ್‌ಗಳು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಎಲ್ಲಿ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಹಳ ಮುಖ್ಯ.

ಸ್ಕೋಪ್‌ನ ವಿಧಗಳು (Types of Scope)

ಪೈಥಾನ್‌ನಲ್ಲಿ ಮುಖ್ಯವಾಗಿ ಎರಡು ರೀತಿಯ ಸ್ಕೋಪ್‌ಗಳಿವೆ:

1. ಲೋಕಲ್ ಸ್ಕೋಪ್ (Local Scope)

ಒಂದು ಫಂಕ್ಷನ್‌ನೊಳಗೆ ಡಿಫೈನ್ ಮಾಡಲಾದ ವೇರಿಯೇಬಲ್‌ಗಳು ಲೋಕಲ್ ಸ್ಕೋಪ್ ಹೊಂದಿರುತ್ತವೆ.
ಈ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಕೇವಲ ಆ ಫಂಕ್ಷನ್‌ನೊಳಗೆ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು.
ಫಂಕ್ಷನ್‌ನ ಚಾಲನೆ ಮುಗಿದ ತಕ್ಷಣ, ಈ ವೇರಿಯೇಬಲ್‌ಗಳು ನಾಶವಾಗುತ್ತವೆ (destroyed).

def my_function():
    x = 10  # x ಒಂದು ಲೋಕಲ್ ವೇರಿಯೇಬಲ್
    print(f"ಫಂಕ್ಷನ್‌ನೊಳಗೆ x: {x}")

my_function()
# print(x)  # NameError: name 'x' is not defined (ಇಲ್ಲಿ x ಲಭ್ಯವಿಲ್ಲ)

2. ಗ್ಲೋಬಲ್ ಸ್ಕೋಪ್ (Global Scope)

ಫಂಕ್ಷನ್‌ಗಳ ಹೊರಗೆ, ಅಂದರೆ ಪ್ರೋಗ್ರಾಮ್‌ನ ಮುಖ್ಯ ಭಾಗದಲ್ಲಿ ಡಿಫೈನ್ ಮಾಡಲಾದ ವೇರಿಯೇಬಲ್‌ಗಳು ಗ್ಲೋಬಲ್ ಸ್ಕೋಪ್ ಹೊಂದಿರುತ್ತವೆ.
ಈ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಪ್ರೋಗ್ರಾಮ್‌ನ ಯಾವುದೇ ಭಾಗದಲ್ಲಿ (ಎಲ್ಲಾ ಫಂಕ್ಷನ್‌ಗಳ ಒಳಗೆ ಮತ್ತು ಹೊರಗೆ) ಪ್ರವೇಶಿಸಬಹುದು.
ಪ್ರೋಗ್ರಾಮ್ ಮುಗಿಯುವವರೆಗೂ ಇವುಗಳ ಲೈಫ್‌ಟೈಮ್ ಇರುತ್ತದೆ.

y = 100  # y ಒಂದು ಗ್ಲೋಬಲ್ ವೇರಿಯೇಬಲ್

def another_function():
    print(f"ಫಂಕ್ಷನ್‌ನೊಳಗೆ y: {y}") # ಗ್ಲೋಬಲ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು

another_function()
print(f"ಫಂಕ್ಷನ್‌ನ ಹೊರಗೆ y: {y}")

`global` ಕೀವರ್ಡ್

ಒಂದು ಫಂಕ್ಷನ್‌ನೊಳಗೆ ಗ್ಲೋಬಲ್ ವೇರಿಯೇಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು, ನಾವು global ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಪೈಥಾನ್ ಆ ಹೆಸರಿನಲ್ಲಿ ಹೊಸ ಲೋಕಲ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

count = 0  # ಗ್ಲೋಬಲ್ ವೇರಿಯೇಬಲ್

def increment():
    global count  # ಗ್ಲೋಬಲ್ 'count' ಅನ್ನು ಬಳಸಲು ಸೂಚನೆ
    count += 1
    print(f"ಫಂಕ್ಷನ್‌ನೊಳಗೆ: {count}")

increment()
increment()
print(f"ಫಂಕ್ಷನ್‌ನ ಹೊರಗೆ: {count}") # Output: 2

LEGB ನಿಯಮ (LEGB Rule)

ಪೈಥಾನ್ ಒಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹುಡುಕುವಾಗ, ಅದು ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಸ್ಕೋಪ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಈ ಕ್ರಮವನ್ನು LEGB ನಿಯಮ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ:

L - Local: ಮೊದಲು, ಪ್ರಸ್ತುತ ಫಂಕ್ಷನ್‌ನ ಲೋಕಲ್ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ.
E - Enclosing: ನಂತರ, ನೆಸ್ಟೆಡ್ ಫಂಕ್ಷನ್‌ಗಳಿದ್ದರೆ, ಹೊರಗಿನ ಫಂಕ್ಷನ್‌ನ (enclosing) ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ.
G - Global: ನಂತರ, ಪ್ರೋಗ್ರಾಮ್‌ನ ಗ್ಲೋಬಲ್ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ.
B - Built-in: ಕೊನೆಯದಾಗಿ, ಪೈಥಾನ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ (built-in) ಹೆಸರುಗಳಲ್ಲಿ (print, len, etc.) ಹುಡುಕುತ್ತದೆ.

ಉದಾಹರಣೆ:

pi = 3.14  # Global

def outer_function():
    pi = 3.14159  # Enclosing

    def inner_function():
        # pi = 3.1415926  # Local (ಇದನ್ನು ಅನ್‌ಕಾಮೆಂಟ್ ಮಾಡಿದರೆ, ಈ ಮೌಲ್ಯ ಪ್ರಿಂಟ್ ಆಗುತ್ತದೆ)
        print(pi) # ಮೊದಲು ಲೋಕಲ್, ನಂತರ ಎನ್‌ಕ್ಲೋಸಿಂಗ್ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ

    inner_function()

outer_function() # Output: 3.14159

`nonlocal` ಕೀವರ್ಡ್

ನೆಸ್ಟೆಡ್ ಫಂಕ್ಷನ್‌ನೊಳಗೆ, ಹೊರಗಿನ (enclosing) ಫಂಕ್ಷನ್‌ನ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು nonlocal ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

def outer():
    message = "ಹೊರಗಿನ ಸಂದೇಶ"

    def inner():
        nonlocal message # ಹೊರಗಿನ ಫಂಕ್ಷನ್‌ನ 'message' ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸಲು ಸೂಚನೆ
        message = "ಒಳಗಿನಿಂದ ಬದಲಾಯಿಸಲಾಗಿದೆ"
        print(f"ಒಳಗೆ: {message}")

    inner()
    print(f"ಹೊರಗೆ: {message}")

outer()

ಔಟ್‌ಪುಟ್:

ಒಳಗೆ: ಒಳಗಿನಿಂದ ಬದಲಾಯಿಸಲಾಗಿದೆ
ಹೊರಗೆ: ಒಳಗಿನಿಂದ ಬದಲಾಯಿಸಲಾಗಿದೆ

ಸ್ಕೋಪ್ ಮತ್ತು ಲೈಫ್‌ಟೈಮ್ ಅನ್ನು ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ದೋಷ-ಮುಕ್ತ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ಬರೆಯಲು ಅತ್ಯಗತ್ಯ.