Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

Python Namespace और Variable के Scope को Explain करें


Python Namespace और Variable Scope

Namespace Scope को Implement करने का एक तरीका है। Python में, प्रत्येक Package, Module, Class, Function और Method Function का अपना एक "Namespace" होता है जिसमें Variable Names Resolve होते हैं। जब कोई Function, Module या Package Evaluate होता है (यानी Execution शुरू होता है), तो एक Namespace Create होता है। इसे "Evaluation Context" के रूप में सोचें। जब कोई Function, आदि, Execution समाप्त करता है, तो Namespace Drop हो जाता है। Variables Drop हो जाते हैं। साथ ही एक Global Namespace होता है जिसका उपयोग तब किया जाता है जब Name Local Namespace में नहीं होता।

प्रत्येक Variable Name को पहले Local Namespace (Function का Body, Module, आदि) में Check किया जाता है, और फिर Global Namespace में Check किया जाता है।

Variables आमतौर पर केवल Local Namespace में Create किए जाते हैं। global और nonlocal Statements Variables को Local Namespace के अलावा अन्य Namespaces में Create कर सकते हैं।

Scope Resolution तब आवश्यक होता है जब किसी Variable का उपयोग यह Determine करने के लिए किया जाता है कि इसका Value कहां से आना चाहिए। Python में Scope Resolution **LEGB Rule** का पालन करता है।

LEGB Rule:

  • L - Local: Function (या Lambda) के भीतर किसी भी तरह से Assign किए गए Names, और उस Function में Global Declare नहीं किए गए
  • E - Enclosing-function Locals: किसी भी और सभी Statically Enclosing Functions (या Lambdas) के Local Scope में Name, Inner से Outer की ओर
  • G - Global (Module): Module File के Top-Level पर Assign किए गए Names, या File के भीतर Def में Global Statement Execute करके
  • B - Built-in (Python): Built-in Names Module में Pre-assigned Names: open, range, SyntaxError, आदि

उदाहरण: LEGB Demonstration

# Built-in (B)
print(len("hello"))  # 5 - Built-in function

# Global (G)
x = 10

def outer():
    # Enclosing (E)
    x = 20
    
    def inner():
        # Local (L)
        x = 30
        print(f"Local x: {x}")        # 30
        print(f"Enclosing x: {x}")    # 30 (Local shadows enclosing)
    
    inner()
    print(f"Enclosing x after inner: {x}")  # 20

outer()
print(f"Global x: {x}")  # 10

global और nonlocal Keywords:

x = 10  # Global

def modify_global():
    global x
    x = 20  # Global x को Modify करता है

def outer():
    x = 100  # Enclosing
    
    def inner():
        nonlocal x  # Enclosing x को Refer करता है
        x = 200
    
    inner()
    print(x)  # 200 - Enclosing Modified!

modify_global()
print(x)  # 20 - Global Modified!

  1. पायथन में नेमस्पेस और स्कोप पायथन में नेमस्पेस और स्कोप

    पायथन में हम वेरिएबल्स, फ़ंक्शन्स, लाइब्रेरीज़ और मॉड्यूल्स आदि से निपटते हैं। इस बात की संभावना है कि जिस वेरिएबल नाम का आप उपयोग करने जा रहे हैं वह पहले से ही किसी अन्य वेरिएबल के नाम के रूप में या किसी अन्य फ़ंक्शन या मेथड के नाम के रूप में मौजूद है। ऐसे परिदृश्य में, हमें यह सीखने की आवश्यकता है

  1. - पायथन फंक्शन में वेरिएबल स्कोप कैसे काम करता है?

    पायथन में एक वेरिएबल तब परिभाषित होता है जब हम इसे कोई मान असाइन करते हैं। हम इसे पहले से घोषित नहीं करते, जैसे हम C और अन्य भाषाओं में करते हैं। हम बस इसका उपयोग शुरू कर देते हैं। x = 141 किसी फाइल या मॉड्यूल के शीर्ष स्तर पर घोषित कोई भी वेरिएबल ग्लोबल स्कोप में होता है। हम इसे फंक्शन्स के अंदर एक

  1. - पायथन फंक्शन में ग्लोबल वेरिएबल का उपयोग कैसे करें?

    शब्दों, ग्लोबल और लोकल एक स्क्रिप्ट या प्रोग्राम के भीतर वेरिएबल की पहुंच से मेल खाते हैं। ग्लोबल वेरिएबल वह है जिसे कहीं भी एक्सेस किया जा सकता है। लोकल वेरिएबल केवल अपने फ्रेम के भीतर एक्सेस किया जा सकता है। लोकल वेरिएबल को वैश्विक रूप से एक्सेस नहीं किया जा सकता। ग्लोबल वेरिएबल्स वे हैं जो फंक्शन