सूची में एक स्ट्रिंग के साथ स्लाइस असाइनमेंट

Question

मैंने काफी कुछ किया है, लेकिन मेरे पास अवधारणा के लिए एक निश्चित उत्तर नहीं है जिसे मैं समझने की कोशिश कर रहा हूं।

अजगर में, अगर मैं इस तरह के रूप में एक सूची ले:

:

L1=['muffins', 'brownies','cookies'] 

और फिर पहले सूचक कोड का उपयोग करके, अर्थात् 'muffins की सूची में किसी ऑब्जेक्ट को बदलने के लिए प्रयास किया

L1[0:1] = 'cake' 

मैं एक सूची एल 1 मिलेगा: फिर भी

['c', 'a', 'k', 'e', 'brownies', 'cookies'] 

अगर मैं एक ही सूची में ले लिया और कार्रवाई (अब स्ट्रिंग केक से 4 तत्वों के साथ):

['cake', 'brownies', 'cookies'] 

किसी को भी व्याख्या कर सकते हैं क्यों कि, वास्तव में:

L1[0:4] = ['cake'] # presumably, it's now passing the string cake within a list? (it passed into the modified list shown above) 

मैं उत्पादन मैं शुरू में वांछित मिल सकता है? मुझे लगता है कि जब मैं "सूची" में बिना किसी के प्रारंभ में केक लेता हूं, तो यह स्ट्रिंग को एक स्ट्रिंग के एक संदर्भ के विपरीत उन वर्णों के संदर्भ के रूप में संग्रहीत करने के लिए स्ट्रिंग को तोड़ देता है ...

लेकिन मुझे पूरी तरह से यकीन नहीं है।

Answer 1

दो महत्वपूर्ण बाते:

1. स्लाइस काम दाएँ हाथ की ओर पर एक iterable लेता है, और iterable द्वारा उत्पादित वस्तुओं के साथ टुकड़ा के तत्वों बदल देता है।
2. पायथन में, स्ट्रिंग्स पुनरावृत्त हैं: एक स्ट्रिंग पर पुनरावृत्त अपने पात्रों को उत्पन्न करता है।

इस प्रकार

L1[0:1] = 'cake' 

अलग-अलग पात्रों 'cake' की साथ L1 के पहले तत्व बदल देता है।

स्ट्रिंग 'cake' साथ पहला तत्व की जगह के लिए, बस लिखना:

L1[0] = 'cake' 

या, टुकड़ा काम सिंटैक्स का उपयोग: एक दृश्य कंटेनर कि वर्ण संग्रहीत करता होने के रूप में

L1[0:1] = ['cake'] 

Answer 2

यदि आप एक टुकड़ा निर्दिष्ट करते हैं, तो राइटथैंड पक्ष को एक सूची/ट्यूपल (वास्तव में, किसी भी पुनरावर्तनीय) के रूप में माना जाता है - लेकिन जेनरेटर के लिए देखें जो अनिश्चित संख्या में मूल्य उत्पन्न करते हैं)।

, एक सूची में किसी आइटम को प्रतिस्थापित करने के का उपयोग करें:।

my_list[0] = "cake" 

(आप भी कर सकता है

my_list[0:1] = ["cake"] 

तुम सच में एक सूची टुकड़ा उपयोग करना चाहते हैं

यहाँ एक हैं जोड़े अन्य प्रासंगिक रेफरी: slice assignment more slice assignment

Answer 3

तार के Think । जब आप इस तरह से असाइनमेंट करने का प्रयास करते हैं, तो यह प्रत्येक आइटम को वर्ण अनुक्रम में सूची में जोड़ता है। अपने स्वयं के 1-तत्व सूची में "केक" को लपेटकर पहले (चलिए इसे एल 2 कहते हैं), आप इसके बजाय एल 2 के प्रत्येक तत्व को एल 1 में जोड़ रहे हैं - यह अनुक्रमिक रूप से बाहरी अनुक्रम से परे अनुक्रम कंटेनर को विभाजित नहीं करता है।

L1 = ['muffins', 'brownies','cookies'] 
L2 = ['cake'] 
L1[0:1] = L2 
print L1 
['cake', 'brownies', 'cookies'] 

यह अन्य नेस्टेड अनुक्रम वस्तुओं के लिए भी सच है। अधिक नेस्टेड अनुक्रम साथ प्रयोग करके देखें इस तरह की वस्तुओं:

L3 = [['pie', 'eclairs'], ['bacon', 'chocolate']] 
L1[0:1] = L3 
print L1 
[['pie', 'eclairs'], ['bacon', 'chocolate'], 'brownies', 'cookies'] 

यह भी ध्यान देने योग्य बात यह है कि यदि आप सूची में के बारे में आदेश/स्थिति परवाह नहीं है, तो आप append() का उपयोग करें और नहीं अपने स्ट्रिंग हो रही विभाजन के बारे में चिंता करने की ज़रूरत कर सकते हैं लायक है अप:

L1 = ['muffins', 'brownies','cookies'] 
L1.append('cake') 
print L1 
['muffins', 'brownies', 'cookies', 'cake']