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

पायथन में आर्गुमेंट्स पास-बाय-वैल्यू या पास-बाय-रेफरेंस कैसे होते हैं?

पायथन "कॉल बाय ऑब्जेक्ट रेफरेंस" (Call by Object Reference) या "कॉल बाय शेयरिंग" नामक तंत्र का उपयोग करता है। यह न तो शुद्ध पास-बाय-वैल्यू है और न ही शुद्ध पास-बाय-रेफरेंस।

मुख्य सिद्धांत

  • इम्यूटेबल ऑब्जेक्ट्स (int, str, tuple, frozenset): पास-बाय-वैल्यू जैसा व्यवहार
  • म्यूटेबल ऑब्जेक्ट्स (list, dict, set, custom objects): पास-बाय-रेफरेंस जैसा व्यवहार

उदाहरण 1: इम्यूटेबल ऑब्जेक्ट (इंटीजर)

def modify_immutable(x):
    print(f"फंक्शन के अंदर पहले: x = {x}, id = {id(x)}")
    x = 20
    print(f"फंक्शन के अंदर बाद: x = {x}, id = {id(x)}")

value = 10
print(f"कॉल से पहले: value = {value}, id = {id(value)}")
modify_immutable(value)
print(f"कॉल के बाद: value = {value}, id = {id(value)}")

आउटपुट

कॉल से पहले: value = 10, id = 140712345678912
फंक्शन के अंदर पहले: x = 10, id = 140712345678912
फंक्शन के अंदर बाद: x = 20, id = 140712345679040  # नया ऑब्जेक्ट!
कॉल के बाद: value = 10, id = 140712345678912      # मूल अपरिवर्तित

उदाहरण 2: म्यूटेबल ऑब्जेक्ट (लिस्ट)

def modify_list(lst):
    print(f"फंक्शन के अंदर पहले: lst = {lst}, id = {id(lst)}")
    lst.append(99)
    print(f"फंक्शन के अंदर बाद: lst = {lst}, id = {id(lst)}")

my_list = [1, 2, 3]
print(f"कॉल से पहले: {my_list}, id = {id(my_list)}")
modify_list(my_list)
print(f"कॉल के बाद: {my_list}, id = {id(my_list)}")

आउटपुट

कॉल से पहले: [1, 2, 3], id = 140712345679104
फंक्शन के अंदर पहले: lst = [1, 2, 3], id = 140712345679104
फंक्शन के अंदर बाद: lst = [1, 2, 3, 99], id = 140712345679104  # समान ऑब्जेक्ट!
कॉल के बाद: [1, 2, 3, 99], id = 140712345679104                # मूल बदल गया!

उदाहरण 3: रीअसाइनमेंट बनाम म्यूटेशन

def reassign_list(lst):
    lst = [10, 20, 30]  # नया ऑब्जेक्ट बनाता है, लोकल वेरिएबल को रीबाइंड करता है
    print(f"अंदर: {lst}")

def mutate_list(lst):
    lst[:] = [10, 20, 30]  # मूल ऑब्जेक्ट को म्यूटेट करता है
    print(f"अंदर: {lst}")

original = [1, 2, 3]
reassign_list(original)
print(f"रीअसाइन के बाद: {original}")  # [1, 2, 3] - अपरिवर्तित!

original = [1, 2, 3]
mutate_list(original)
print(f"म्यूटेट के बाद: {original}")   # [10, 20, 30] - बदल गया!

उदाहरण 4: डिक्शनरी (म्यूटेबल)

student = {'Archana': 28, 'Krishna': 25, 'Ramesh': 32}

def update_student(data):
    new_students = {'Alok': 30, 'Nevadan': 28}
    data.update(new_students)  # म्यूटेशन - मूल बदलता है
    print("फंक्शन के अंदर:", data)

update_student(student)
print("बाहर:", student)

आउटपुट

फंक्शन के अंदर: {'Archana': 28, 'Krishna': 25, 'Ramesh': 32, 'Alok': 30, 'Nevadan': 28}
बाहर: {'Archana': 28, 'Krishna': 25, 'Ramesh': 32, 'Alok': 30, 'Nevadan': 28}

सर्वोत्तम अभ्यास

  1. इम्यूटेबल आर्गुमेंट्स के लिए: चिंता न करें, मूल अपरिवर्तित रहता है
  2. म्यूटेबल आर्गुमेंट्स के लिए: यदि मूल नहीं बदलना चाहते, तो कॉपी पास करें:
    func(my_list[:])        # शैलो कॉपी
    func(list(my_list))       # शैलो कॉपी
    func(copy.deepcopy(obj))  # डीप कॉपी (नेस्टेड स्ट्रक्चर के लिए)
  3. डिफ़ॉल्ट आर्गुमेंट्स में म्यूटेबल ऑब्जेक्ट्स न दें:
    # खतरनाक!
    def bad_func(items=[]):
        items.append(1)
        return items
    
    # सुरक्षित
    def good_func(items=None):
        if items is None:
            items = []
        items.append(1)
        return items

सारांश

परिदृश्यव्यवहारमूल ऑब्जेक्ट बदलता है?
इम्यूटेबल आर्गुमेंटपास-बाय-वैल्यू जैसानहीं
म्यूटेबल आर्गुमेंट + म्यूटेशनपास-बाय-रेफरेंस जैसाहाँ
म्यूटेबल आर्गुमेंट + रीअसाइनमेंटलोकल रीबाइंडिंगनहीं
  1. - C# में पैरामीटर्स कैसे पास किए जाते हैं?

    C# में पैरामीटर्स को या तो वैल्यू द्वारा या रेफरेंस द्वारा पास किया जाता है। इसके साथ, आप आउट पैरामीटर्स और पैराम ऐरे का उपयोग करके पैरामीटर्स पास कर सकते हैं:वैल्यू द्वारायह मेथड एक आर्गुमेंट के वास्तविक मान को फंक्शन के फॉर्मल पैरामीटर में कॉपी करता है। इस मामले में, फंक्शन के अंदर पैरामीटर में कि

  1. पायथन मैटप्लॉटलीब में मल्टीवेरिएट फंक्शन कैसे प्लॉट करें? पायथन मैटप्लॉटलीब में मल्टीवेरिएट फंक्शन कैसे प्लॉट करें?

    पायथन में मल्टीवेरिएट फंक्शन प्लॉट करने के लिए, हम निम्नलिखित चरण अपना सकते हैं: चरण फिगर साइज़ सेट करें और सबप्लॉट्स के बीच और आसपास पैडिंग एडजस्ट करें। नम्पी का उपयोग करके रैंडम x, y और z डेटा पॉइंट्स बनाएं। एक फिगर और सबप्लॉट्स का सेट बनाएं। x, y और z डेटा पॉइंट्स के साथ स्कैटर प्लॉट बनाएं। स्

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

    ये मूल रूप से रनटाइम पर बनाए गए अनाम वन-लाइन फंक्शन्स हैं जो फंक्शन्स के नाम से बाउंड नहीं होते। वे फंक्शन की परिभाषा को ऑन-द-फ्लाई लौटाते हैं। लैम्ब्डा फंक्शन्स में रिटर्न स्टेटमेंट नहीं होता, वे हमेशा एक एक्सप्रेशन लौटाते हैं। आप लैम्ब्डा परिभाषा को कहीं भी रख सकते हैं जहां फंक्शन की अपेक्षा हो। म