पाइथन के लिए नया, यह समझने की कोशिश कर रहा है कि इस पुनरावृत्ति लूप का उद्देश्य सभी वस्तुओं को हटाने के उद्देश्य से सूची में इंडेक्स को कैसे संभालना है और यह कहां बंद हो जाता है ...
यह लूप क्यों है:
foo = ["a", "b", "c", "d", "e", "f", "g", "h"]
for i in foo:
foo.remove(i)
print foo
यहाँ रुको?
["b", "d", "f", "h"]
यहां के बजाय?
["H"]
इसके अलावा, यहां इंडेक्स के साथ "हुड के नीचे क्या हो रहा है"?
प्रत्येक पुनरावृत्ति के साथ, पाइथन का ट्रैक रखना हैएक ही समय में कौन सा इंडेक्स अगली बार है, एक बार आइटम को हटा दिए जाने के बाद आइटम को दाईं ओर एक इंडेक्स ले जाता है (और यही कारण है कि यह हर दूसरे आइटम को छोड़ रहा है)?
उत्तर:
उत्तर № 1 के लिए 1यह समझने के लिए कि यह क्यों हो रहा है, आइए आंतरिक रूप से क्या हो रहा है, चरण-दर-चरण देखें।
चरण 1:
>>> foo = ["a", "b", "c", "d", "e", "f", "g", "h"]
यहां, एक नई सूची वस्तु बनाई गई है और इसे असाइन किया गया है foo.
चरण 2:
>>> for i in foo:
अब, पुनरावृत्ति शुरू होती है। i लूप वैरिएबल को आइटम का मूल्य असाइन किया जाता है सूचकांक 0 जो है "a".
चरण 3:
>>> foo.remove(i)
>>> print foo
["b", "c", "d", "e", "f", "g", "h"]
अभी व, .remove(i) प्रदर्शन .remove(foo[0]) और नहीं .remove("a") जाहिरा तौर पर। नई सूची में अब है "b" सूचकांक 0 पर, "c" सूचकांक 1 और इतने पर।
चरण 4:
>>> for i in foo:
अगले पुनरावृत्ति के लिए, i लूप वेरिएबल को वर्तमान में इंडेक्स 1 पर आइटम का मान असाइन किया गया है "c".
चरण 5:
>>> foo.remove(i)
>>> print foo
["b", "d", "e", "f", "g", "h"]
अब इस बार, .remove(i) प्रदर्शन .remove(foo[1]) जो हटा देता है "c" सूची से। वर्तमान सूची में अब है "b" सूचकांक 0 पर, "d" सूचकांक 1 और इतने पर।
चरण 6:
>>> for i in foo:
अगले पुनरावृत्ति के लिए, i लूप वैरिएबल को आइटम का मूल्य असाइन किया जाता है सूचकांक 2 जो वर्तमान में है "e".
चरण 7:
>>> foo.remove(i)
>>> print foo
["b", "d", "f", "g", "h"]
अब इस बार, .remove(i) प्रदर्शन .remove(foo[2]) जो हटा देता है "e" सूची से। इसी तरह, वस्तुओं के सूचकांक ऊपर चरण 5 में बदल जाते हैं।
चरण 8:
>>> for i in foo:
अगले पुनरावृत्ति के लिए, i लूप वैरिएबल को आइटम का मूल्य असाइन किया जाता है सूचकांक 3 जो वर्तमान में है "g".
चरण 9:
>>> foo.remove(i)
>>> print foo
["b", "d", "f", "h"]
अब इस बार, .remove(i) प्रदर्शन .remove(foo[3]) जो हटा देता है "g" सूची से।
चरण 10:
>>> for i in foo:
अभी व, i आइटम को इंगित करना चाहिए सूचकांक 4 लेकिन चूंकि मूल सूची को 4 तत्वों में घटा दिया गया है, इसलिए निष्पादन यहां रुक जाएगा।
>>> foo
["b", "d", "f", "h"]
निष्पादन के बाद अंतिम सूची है।
कुछ निष्कर्ष:
उन पर इशारा करते समय सूची की लंबाई को कभी भी बदलें। सरल शब्दों में, इस पर पुनरावृत्ति करते समय मूल सूची को संशोधित न करें।
प्रदर्शन करते समय
.remove()एक सूची में क्रमशः, लूप वैरिएबल इंडेक्स का उपयोग करके सूची आइटम को संदर्भित करेगा, न कि मूल सूची में वास्तविक वस्तुओं द्वारा।
जवाब के लिए 3 № 2
यह सूचकांक शून्य से शुरू होता है, वहां "ए" को हटा देता है। इसके बाद यह "डी" को हटाकर, सूचकांक में स्थानांतरित हो जाता है। ("सी" नहीं, क्योंकि यह इस बिंदु पर सूचकांक शून्य पर है।) फिर सूची में केवल दो आइटम शेष हैं, इसलिए यह इंडेक्स दो पर नहीं जा सकता है, और लूप समाप्त होता है।
शायद एक के बजाय for लूप, आप एक का उपयोग कर सकते हैं while लूप जो तब तक जारी रहता है जब तक सूची खाली न हो।
foo = ["A", "C", "D", "E"]
while foo:
foo.pop(0)
print foo
... या आप सूची की एक प्रतिलिपि पर फिर से शुरू कर सकते हैं, जो आपके द्वारा संशोधित के रूप में आपके नीचे से नहीं बदलता है foo। बेशक, यह थोड़ा अतिरिक्त स्मृति का उपयोग करता है।
foo = ["A", "C", "D", "E"]
for i in foo[:]:
foo.remove(i)
print foo