पायथन "कॉल बाय ऑब्जेक्ट रेफरेंस" (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}
सर्वोत्तम अभ्यास
- इम्यूटेबल आर्गुमेंट्स के लिए: चिंता न करें, मूल अपरिवर्तित रहता है
- म्यूटेबल आर्गुमेंट्स के लिए: यदि मूल नहीं बदलना चाहते, तो कॉपी पास करें:
func(my_list[:]) # शैलो कॉपी func(list(my_list)) # शैलो कॉपी func(copy.deepcopy(obj)) # डीप कॉपी (नेस्टेड स्ट्रक्चर के लिए)
- डिफ़ॉल्ट आर्गुमेंट्स में म्यूटेबल ऑब्जेक्ट्स न दें:
# खतरनाक! def bad_func(items=[]): items.append(1) return items # सुरक्षित def good_func(items=None): if items is None: items = [] items.append(1) return items
सारांश
| परिदृश्य | व्यवहार | मूल ऑब्जेक्ट बदलता है? |
|---|---|---|
| इम्यूटेबल आर्गुमेंट | पास-बाय-वैल्यू जैसा | नहीं |
| म्यूटेबल आर्गुमेंट + म्यूटेशन | पास-बाय-रेफरेंस जैसा | हाँ |
| म्यूटेबल आर्गुमेंट + रीअसाइनमेंट | लोकल रीबाइंडिंग | नहीं |