बनाम वृद्धि

Question

सूची यह देखते हुए कि अजगर में जोड़े

element += [0] 

एक एक सूची क्यों संशोधित करता है और अन्य नहीं करता है? यहां एक उदाहरण दिया गया है:

>>> a = [[0, 0], [0,0]] 
>>> for element in a: 
...  element = element + [0] 
... 
>>> a 
[[0, 0], [0, 0]] 

कोई संशोधित नहीं है। लेकिन अगर मैं वृद्धि करता हूं:

>>> a = [[0, 0], [0,0]] 
>>> for element in a: 
...  element += [0] 
... 
>>> a 
[[0, 0, 0], [0, 0, 0]] 

एक संशोधित है।

धन्यवाद, फ्रैंक

Answer 1

यह += operatior, जो __iadd__ बजाय __add__ कॉल की एक मजेदार पक्ष प्रभाव है।

कथन x = x + yx = x.__add__(y) के बराबर है, जबकि x += yx = x.__iadd__(y) के बराबर है।

यह list वर्ग का अनुकूलन += मौजूदा बढ़ा कर देता है के बजाय सूची एक पूरी तरह से नई सूची (जो + क्या करने की जरूरत है) बनाने (पूर्व, x += y मोटे तौर पर x.extend(y) के बराबर है)।

उदाहरण के लिए:

 
>>> a = [1, 2, 3] 
>>> original_a = a 
>>> b = [1, 2, 3] 
>>> original_b = b 
>>> a += [4] 
>>> b = b + [4] 
>>> a is original_a 
True 
>>> b is original_b 
False 

आप देख सकते हैं कि += का उपयोग कर बाएं हाथ की ओर की पहचान रखता है (यानी, एक नई सूची बनाया नहीं है), जबकि + का उपयोग कर प्रबंधित नहीं करता है पहचान (यानी, एक नई सूची बनाई गई है)।

अधिक के लिए, http://docs.python.org/library/operator.html#operator.iadd और सीधे operator.iadd के लिए प्रलेखन के ऊपर अनुच्छेद देखें।

Answer 2

पहले मामले में, तत्व = तत्व + [0], आप एक नई सूची बना रहे हैं।

दूसरे मामले में, तत्व + = [0], आप मौजूदा सूची को संशोधित कर रहे हैं।

सूचियों की सूची के बाद से, तत्वों के पॉइंटर्स होते हैं, केवल तत्वों को संशोधित करने से चीजें वास्तव में बदल जाएंगी। (यह एक नई सूची बनाने के लिए एक में संकेत परिवर्तन नहीं करता है, है।)

यह और अधिक स्पष्ट रूप से देखा जाता है, तो हम एक सरल तरीका दिखाते हुए सूचियों के काम उदाहरण लेते:

>>> a = [1, 2, 3] 
>>> b = a 
>>> a = [4, 5, 6] 
>>> a 
[4, 5, 6] 
>>> b 
[1, 2, 3] 
>>> a = [1, 2, 3] 
>>> b = a 
>>> a += [4, 5, 6] 
>>> b 
[1, 2, 3, 4, 5, 6] 
>>> a 
[1, 2, 3, 4, 5, 6] 

एक सूची के लिए एक चर असाइन करना बस एक सूचक निर्दिष्ट करता है।

Answer 3

क्या अन्य लोगों ने कहा करने के लिए जोड़ा जा रहा है, वहाँ क्या इन बयानों कर में एक फर्क है:

element = element + [0] 

element = element.__add__([0]) 

जबकि

element += [0] 

करता है

element = element.__iadd__([0]) 

__iadd__(), इस मामले में, यह निर्धारित करने के लिए स्वतंत्र है कि क्या वापस करना है: मूल वस्तु एक संशोधन या एक नई वस्तु के साथ।

एक अपरिवर्तनीय वस्तु के मामले में, यह एक अलग से एक (जैसे, a = b = 8; a += 9 =>a is not b लौटना चाहिए

लेकिन एक परिवर्तनशील वस्तु के मामले में, इस तरह के एक सूची के रूप में, यह आम तौर पर यह एक संशोधित करता है।: ।

a = b = [] 
a += [8] 

=>a is b

यह अलग व्यवहार में दर्शाता है अपने पाश के लिए:

for element in a: 
    element = element + [0] 

=> नाम element एक अलग वस्तु के लिए वापसी हो जाता है; मूल एक अछूता

for element in a: 
    element += [0] 

=> मूल वस्तु है, जो साथ ही बाहरी सूची, a में निहित है बनी हुई है, संशोधित हो जाता है। तथ्य यह है कि element पुन: असाइन किया गया है अप्रासंगिक है; इसका उपयोग नहीं किया जाता है।