सभी अलग-अलग पृथक्करण

Question

के भीतर मित्र प्राप्त करना। मैं एक बहुत ही नया प्रोग्रामर हूं। इस समय मेरी पसंद की भाषा पाइथन है, और मुझे लगता है कि इसके लिए मुझे सभ्य अनुभव है। मैं अभी रिकर्सन के बारे में सीखना शुरू कर रहा हूं। (वैसे, अगर कोई इस पर एक अच्छी मार्गदर्शिका की सिफारिश कर सकता है, तो कृपया मुझे बताएं!) बस इतना ही आप सभी जानते हैं, यह सवाल बहुत प्राथमिक है, और जिस कोड को मैं पोस्ट कर रहा हूं वह बहुत ही गलत है।

वैसे भी, मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो सभी मित्रों को निर्दिष्ट डिग्री के भीतर प्राप्त करे। अगर मैं इसे 0 डिग्री के रूप में पास करता हूं, तो मैं बस खुद को चाहता हूं। अगर मैं इसे पास करता हूं, तो मैं और मेरे सभी दोस्तों को चाहता हूं। 2, मैं चाहता हूं कि मैं, मेरे दोस्त, और उनके सभी दोस्तों, और इसी तरह।

मैंने ऐसा करने के कुछ अलग-अलग तरीकों की कोशिश की है, लेकिन कोई भी काम नहीं है। मैं कल्पना करने की कोशिश करता हूं कि इसे सिद्धांत में कैसे काम करना चाहिए, और मैं इसे इसलिए नहीं प्राप्त कर सकता क्योंकि मैं इस क्षेत्र में इतना अनुभवहीन हूं। हो सकता है कि यहां एक दयालु आत्मा मुझे सभी तरीकों से दिखा सके जिसमें यह कोड विफल हो गया है और फिर समझाएं कि यह कैसे ठीक से करें और/या विषय पर एक अच्छी मार्गदर्शिका की अनुशंसा करें। यहाँ जाता है:

def getFriends(self,degree,friendList): 
     if degree == 0: 
      friendList.append(self) 
      return friendList 
     else: 
      friendList = friendList.append(self) 
      for each in self.friends: 
       each.getFriends(degree-1,friendList) 

यह काम नहीं करता है, और मैं जानता हूँ कि मैं बेवकूफ, बेवकूफ कार्य कर लेते हैं। किसी ने मुझे थप्पड़ मारो और मुझे सही दिशा में इंगित करें!

धन्यवाद।

Answer 1

friendList = friendList.append(self) 

यह friendListNone करने के लिए सेट बिना शर्त, के रूप में है कि किसी भी सूची के append विधि की अचल वापसी मान है - हां, कि weirdness ठीक पहले ... -!)

एक बार आपके द्वारा निश्चित है कि, आपको अभी भी फ़ंक्शन को ठीक करने की आवश्यकता है ताकि यह हमेशा return के साथ समाप्त हो - "अंत से गिरने" रिटर्न None। उदाहरण के लिए:

def getFriends(self,degree, friendList): 
    friendList.append(self) 
    if degree > 0: 
     for each in self.friends: 
      each.getFriends(degree-1, friendList) 
    return friendList 

पुनश्च::

def getFriends(self,degree, friendList): 
    if degree == 0: 
     friendList.append(self) 
     return friendList 
    else: 
     friendList.append(self) 
     for each in self.friends: 
      each.getFriends(degree-1, friendList) 
     return friendList 

और स्पष्ट रूप से डुप्लिकेशन समाप्त करने के पुनर्संशोधित किया जाना चाहिए सकता है, जो (सूखी, अपने आप को दोहराना नहीं, प्रोग्रामिंग के दिल ... है) कि (alist=alist.append(...) अंक) ठीक 2002 में मैं अपनी पत्नी अन्ना के संपर्क में कैसे आया था (हम कई साल पहले बहुत प्यारे दोस्त नहीं थे लेकिन एक-दूसरे का ट्रैक खो चुके थे) - उसने पाइथन का अध्ययन करना शुरू किया, बिल्कुल इस्तेमाल किया यह गलत निर्माण, समझ में नहीं आया कि यह क्यों विफल रहा - पाइथन समुदाय के चारों ओर देखा, देखा और मेरा नाम पहचाना , मुझे इसके बारे में पूछने के लिए मेल किया ... दो साल से भी कम समय बाद हम शादी कर चुके थे, और जल्द ही वह पाइथन सॉफ्टवेयर फाउंडेशन की पहली महिला सदस्य और "पायथन कुकबुक" में मेरे सह-लेखक थे। तो, ज़ाहिर है, मुझे इस विशिष्ट पायथन त्रुटि के लिए अविश्वसनीय मीठा स्थान मिला है ... ;-)।

Answer 2

यदि आप दोस्त से पहले लाइन पर दोस्त लिस्ट.एपेंड (स्वयं) को स्थानांतरित कर सकते हैं - आपको दोनों मामलों में इसकी आवश्यकता है। आपको परिणाम को मित्र सूची में असाइन करने की आवश्यकता नहीं है - यह एक बग है।

आपके एल्गोरिदम में, आप एक ही लोगों को दो बार जोड़ सकते हैं - यदि ए बी और बी का मित्र है तो ए का मित्र है, इसलिए आपको पहले से संसाधित मित्रों का एक सेट रखना होगा। प्रसंस्करण से पहले, इस सेट को जांचें और अगर कुछ व्यक्ति पहले ही संसाधित हो गया है तो कुछ भी न करें।

Answer 3

क्या आपकी पहचान सही है?विधि के शरीर को इसकी परिभाषा के सापेक्ष इंडेंट किया जाना चाहिए

Answer 4

else खंड में कोई return कथन नहीं है। तो यदि degree != 0, यह विधि हमेशा None लौटाएगी। आप प्रत्येक रिकर्सिव getFriends के परिणाम को अपने friendList पर कॉल करना चाहते हैं, और फिर friendList पर वापस आएं।

वैसे, यदि आप इस एल्गोरिदम को तेज़ी से बनाना चाहते हैं, तो ग्राफ एल्गोरिदम या मैट्रिक्स मैनिपुलेशन के साथ ऐसा करने के लिए अच्छी तरह से स्थापित विधियां हैं। उदाहरण के लिए, यदि आप आसन्नता मैट्रिक्स A के साथ दोस्ती संबंधों का प्रतिनिधित्व करते हैं, और आप सभी लोगों को n डिग्री एक दूसरे के अलगाव के भीतर खोजना चाहते हैं, तो आप B=A^n की गणना कर सकते हैं। यदि B[i][j] > 0, तो i और j एक दूसरे के अलगाव के n डिग्री के भीतर हैं। NumPy जैसे पैकेज के साथ मैट्रिक्स गुणा आसान है।

Answer 5

(क्षमा करें, मैं एलेक्स के जवाब पर टिप्पणी नहीं कर सकता ... अभी तक)

मैं विचार है कि getFriends एक मूल्य है कि इस्तेमाल कभी नहीं देता है की तरह वास्तव में नहीं है। यह निश्चित रूप से काम करता है, लेकिन यह थोड़ा सा दिलचस्प लग रहा है;) इसके अलावा, प्राप्त करने वाला पहला कॉल स्वयं होगा .getFriends (डिग्री, []) जो भ्रमित है: दोस्तों की एक सूची प्राप्त करते समय, आप एक के रूप में क्यों गुजरेंगे एक खाली सूची तर्क, सही?

स्पष्टता के लिए, मुझे लगता है कि मैं इस थोड़ा अलग संस्करण पसंद करेंगे, _getFriends सहायक फ़ंक्शन का उपयोग:

def getFriends(self, degree): 
    friendList = [] 
    self._getFriends(degree, friendList) 
    return friendList 

def _getFriends(self, degree, friendList): 
    friendList.append(self) 
    if degree: 
     for friend in self.friends: 
      friend._getFriends(degree-1, friendList)