जब मैं इसके अंदर एक सूची में संलग्न होता हूं तो टुपल की सामग्री क्यों बदलती है लेकिन जब मैं एक चर अद्यतन करता हूं तो नहीं बदलता है?

Question

myVar = ["jhhj", "hgc"] 
myTuple = ([1,2,3], [4,5,6], myVar) 
myVar.append('lololol') 
print myTuple 

निर्माण के बाद संलग्न करके इस ट्यूपल को क्यों और कैसे संशोधित किया जा सकता है?

myVar = "lol" 
myTuple = ([1,2,3], [4,5,6], myVar) 
myVar = "lolol" 
print myTuple 

क्यों इस ([1,2,3], [4,5,6], "lol") बजाय ([1,2,3], [4,5,6], "lolol") बाहर मुद्रित करने के लिए जा रहा है? तो आप एक नया टपल के निर्माण के लिए यदि आप अपने सदस्यों में से एक को संशोधित करना चाहता था की आवश्यकता होगी

Answer 1

ठीक है, मुझे कुछ छवियों के साथ समझाने की कोशिश करते हैं।

पायथन में, सब कुछ एक वस्तु है। उन वस्तुओं को संदर्भित चर द्वारा संदर्भित किया गया है। सूचियों और tuples जैसे कुछ प्रकार की वस्तुओं, बस अन्य वस्तुओं के संदर्भ स्टोर।

कहा, जब आप पर अमल

myVar = ["jhhj", "hgc"] 
myTuple = ([1,2,3], [4,5,6], myVar) 

आप कम या ज्यादा इस परिदृश्य मिलती है:

प्रत्येक वस्तु एक बॉक्स/आयत द्वारा दर्शाया गया। हमारे पास दो स्ट्रिंग ऑब्जेक्ट्स हैं, "jhhj" और "hgc"। इसके अलावा, हमारे पास एक सूची वस्तु है, जो चर myVar द्वारा इंगित की गई है; यह सूची ऑब्जेक्ट दोनों स्ट्रिंग ऑब्जेक्ट्स को इंगित करती है। इसके अलावा, हमारे पास एक tuple वस्तु है, myTuple द्वारा संदर्भित; यह ट्यूपल ऑब्जेक्ट दो अन्य सूचियों और myVar द्वारा संदर्भित सूची को इंगित करता है।

जब आप

myVar.append('lololol') 

क्या होता है पर अमल?

नोट myVar अभी भी संदर्भ सूची वस्तु: ठीक है, सूची वस्तु (जो संयोग से myVar द्वारा बताया जाता है) एक और मूल्य, स्ट्रिंग वस्तु "lololol" संदर्भित करने के लिए शुरू होता है। क्या हुआ कि सूची वस्तु बदल गई।आप इस सूची ऑब्जेक्ट को myVar से या टुपल से देख सकते हैं, आप एक ही ऑब्जेक्ट को उसी परिवर्तन के साथ देखेंगे।

OTOH, जब आप पर अमल

myVar = "lol" 
myTuple = ([1,2,3], [4,5,6], myVar) 

आप कुछ इस तरह मिलती है:

अब स्ट्रिंग वस्तु "lol" करने के लिए myVar अंक, साथ ही टपल संदर्भ वह अपने तीसरे स्थान पर । अब, आप निष्पादित

myVar = "lolol" 

आप सिर्फ एक और वस्तु को इंगित करने के myVar बना रहे हैं। टपल वस्तु अभी भी पहले की तरह "lol" को इंगित करता है:

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

पीएस: इसके अलावा, I answered a vaguely related question some time ago। आपको उत्तर उपयोगी मिल सकता है।

* अगर यह कचरा कलेक्टर द्वारा एकत्र किया जाता है, लेकिन यह एक और लंबा इतिहास है।

Answer 2

tuples, अपरिवर्तनीय हैं ...

Answer 3

अजगर में सभी चीजों वस्तुओं रहे हैं।

तो जब आप अपने मूल काम

myVar = "lol"

आप फिर आप एक टपल बनाने वस्तु "lol"

myVar एक संदर्भ दे रहे हैं है। तीसरे स्लॉट में इस ट्यूपल में "lol"

का संदर्भ है, फिर आप एक नया ऑब्जेक्ट "lolol" बनाते हैं और myVar को इसका संदर्भ देते हैं। टपल अपने मूल संदर्भ बरकरार रखती है "lol"

Answer 4

tuples अपरिवर्तनीय हैं, लेकिन आप उन्हें एक साथ जोड़ सकते हैं:

var a = (1, 2) 
var b = a + (3, 4) 

Answer 5

दोनों मामलों में, जब आप टुपल बनाते हैं तो आप उस ऑब्जेक्ट के संदर्भ को प्रतिलिपि बना रहे हैं myvar उस समय था।

पहले मामले में, myvar एक उत्परिवर्तनीय वस्तु है। आप इसके संदर्भ के बाद ऑब्जेक्ट को बदल सकते हैं tuple में संग्रहीत किया गया है।

दूसरे मामले में, myvar एक अपरिवर्तनीय स्ट्रिंग है। आप ऑब्जेक्ट को नहीं बदल सकते हैं, लेकिन आप myvar को बदल सकते हैं। यह उस वस्तु को नहीं बदलता है जो टुपल के भीतर निहित है।

Answer 6

वहाँ अन्य उत्तर है कि मैं फिर से पुनरावृति नहीं होगा एक बार फिर में कुछ महान अंक दिया गया है, नाम और वस्तुओं के बीच का अंतर समझा। मुझे लगता है कि कुछ पाइथन कोड नामों पर चल रहा है और जब यह ऑब्जेक्ट्स पर चल रहा है, तो मुझे लगता है कि गायब है।

एक महत्वपूर्ण चीज जिसे आपको समझने की आवश्यकता है, यह है कि केवल चीज जो सीधे नामों को प्रभावित करती है असाइनमेंट स्टेटमेंट [1] है। एक असाइनमेंट स्टेटमेंट एक अलग ऑब्जेक्ट को इंगित करने के लिए नाम को दोबारा जोड़ता है। में कोई नाम दिखाई देने वाला कोई भी नाम अन्य संदर्भ कोड के उस पंक्ति को तब तक सीमित किया जाता है जब कोड की उस पंक्ति को निष्पादित किया जाता है।

अपने उदाहरण से इस लाइन पर देखने की सुविधा देता है:

myTuple = ([1,2,3], [4,5,6], myVar) 

myTuple असाइनमेंट बयान की बाईं ओर स्थित है, इसलिए नामmyTuple वहाँ क्या प्रभावित किया जा रहा है है।myVar दूसरी तरफ एक अभिव्यक्ति के अंदर है, इसलिए यह ऑब्जेक्टmyVar है जो ट्यूपल का तीसरा तत्व है, नाम myVar है।

परिणामस्वरूप, नामmyVar पर जो भी हो, वह ट्यूपल पर कोई प्रभाव नहीं पड़ता है। लेकिन जब तक टपल के तीसरे तत्व और myVar के रूप में बदल रहा है कि वस्तु (या तो myVar या टपल के माध्यम से) स्पष्ट रूप से जब आप या तो संदर्भ के माध्यम से वस्तु को देखने के आप क्या मिलता है को प्रभावित करेगा, एक ही वस्तु को देखें।

---

[1] उन्नत अध्ययन के लिए, def और class बयान भी "काम बयानों" (वे एक समारोह या एक वर्ग बनाने और उसके बाद नाम के लिए असाइन करें) कर रहे हैं।

इसके अलावा, ऑपरेटरों +=, *=, आदि जैसे कभी कभी काम बयानों और कभी कभी नहीं, वस्तु वर्तमान में एलएचएस पर नाम से संबोधित किया जाता के प्रकार पर निर्भर कर रहे हैं:

myList = [] 
myList += ['this calls a method on a list object which mutates it in place; the name is not changed'] 

myInt = 1 
myInt += 10 # This rebinds myInt to refer to a new object 11; the object 1 is not changed 

तो