अगर मैं अतिरिक्त मूल्य पर पुन: प्रयास करना चाहता हूं तो पुनरावृत्ति के दौरान एक सूची में शामिल होना सुरक्षित है? कोड

Question

मैं अक्सर अपने आप को तैयार करने जैसा:

mylist = [247] 
while mylist: 
    nextlist = [] 
    for element in mylist: 
     print element 
     if element%2==0: 
      nextlist.append(element/2) 
     elif element !=1: 
      nextlist.append(3*element+1) 
    mylist = nextlist 

ठीक है - यह आम तौर पर इस सरल नहीं है [और आमतौर पर यह वास्तव में बड़ी सूचियों वाले है, मैं सिर्फ यह मनोरंजन के लिए (xkcd देखें) चुना है], लेकिन मैं एक बनाने सूची, उन तत्वों के साथ चीजों को करने पर इसे फिर से शुरू करें। ऐसा करने के दौरान, मैं नई चीजों की खोज करूंगा जिन्हें मुझे फिर से शुरू करने की आवश्यकता होगी, और मैंने उन्हें एक नई सूची में रखा जो मैं फिर से शुरू करता हूं।

यह लिखने के लिए संभव हो गया लगता है:

mylist=[247] 
for element in mylist: 
    print element 
    if element%2 == 0: 
     mylist.append(element/2) 
    elif element !=1: 
     mylist.append(element*3+1) 

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

क्या ऐसा करने से कोई खतरा है? केवल एक ही मैं सोच सकता हूं कि सूची बढ़ सकती है और बहुत सारी मेमोरी ले सकती है (मेरे कई मामलों में मैं वास्तव में अंत में पूरी सूची रखना चाहता हूं)। क्या मैं दूसरों को अनदेखा कर रहा हूं?

कृपया ध्यान दें: Python: Adding element to list while iterating संबंधित है, लेकिन सूची की एक प्रति बनाने के तरीके बताते हैं ताकि हम मूल पर पुनरावृत्ति से बच सकें। मैं इस बारे में पूछ रहा हूं कि मेरे विशिष्ट मामले में कुछ भी गलत है, जहां मैं वास्तव में अपने पुनरावृत्ति को विस्तारित करना चाहता हूं।

---

संपादित: यहाँ वास्तविक समस्या के करीब कुछ है। मान लें कि हम नेटवर्क के "के-कोर" उत्पन्न करना चाहते हैं। यही है, के साथ कम डिग्री के साथ सभी नोड्स हटा दें। शेष नेटवर्क से के साथ कम डिग्री के साथ सभी नोड्स हटा दें। हटाए जाने के लिए कोई भी नहीं छोड़ा जब तक दोहराएं। एल्गोरिदम को शुरू करने के लिए के नोड्स से कम सभी मिलेंगे, उन्हें एक to_delete सूची में डाल दें। फिर जैसे नोड्स हटा दिए जाते हैं, यदि पड़ोसी की डिग्री के -1 हो जाती है, तो इसे सूची में जोड़ें। यह द्वारा किया जा सकता है:

delete_list = [node for node in G.nodes() if G.degree(node)<k] 
for node in delete_list: 
    nbrs = G.neighbors(node) 
    for nbr in nbrs: 
     if G.degree(nbr)==k: 
      delete_list.append(nbr) 
    G.remove_node(node) 

Answer 1

हाँ, यह एक सूची में जोड़ने के लिए आप पर पुनरावृत्ति कर रहे हैं, कम से कम जिस तरह से है कि आप इसे कर रहे हैं में काफी सुरक्षित है। एकमात्र मुद्दा यह होगा कि यदि सूची इतनी बड़ी हो गई कि इससे स्मृति समस्याएं हुईं, हालांकि यह केवल आपके लिए बहुत बड़ी संख्या के साथ एक मुद्दा होगा।

उस ने कहा, मैं शायद इस मामले में while पाश का उपयोग करूंगा, चाहे आप अंत में पूरी सूची चाहते हों या नहीं।

current = 247 
result_list = [current] 

while current != 1: 
    if current % 2 == 0: 
     current /= 2 
    else: 
     current = current * 3 + 1 

    result_list.append(current) 

हालांकि वास्तव में मैं शायद जनरेटर का उपयोग करूंगा।

def collatz(start): 
    current = start 

    yield current 

    while current != 1: 
     if current % 2 == 0: 
      current /= 2 
     else: 
      current = current * 3 + 1 

     yield current 

Collatz conjecture पर चिल्लाओ! : डी

Answer 2

चूंकि यह (वर्तमान में) लागू हुआ है, क्योंकि यह निर्दिष्ट नहीं है।

इसका मतलब है कि यह एक जोखिम भरा विचार है सूची को संशोधित करने के लिए है, जबकि इसके माध्यम से पुनरावृत्ति और पर निर्भर है कि व्यवहार रहेगा। एक सकता है निश्चित रूप से लोगों का तर्क है कोई कारण नहीं क्यों व्यवहार इस मामले में बदल जाएगा है कि वहाँ, लेकिन यह एक धारणा पर निर्भर है कि परिवर्तन होता है करने के लिए एक कारण की जरूरत है।