Erzeugen eines Baumes, der Zweige haben kann, die [Python] beenden

Question

Ich versuche ein Skript zu erstellen, das einen Baum auf die folgende Weise generiert: wenn Nummer jemals ist: in 3 Zahlen teilen: Nummer // 2, Nummer * 2, Nummer + 15. Wenn Nummer ungerade ist: in 2 Zahlen aufteilen: Nummer +1, Zahl * 4. Diese Zweige werden fortgesetzt, bis ein Zweig entweder: größer als 100, gleich 6 ist, ein perfektes Quadrat (Quadratwurzel der Zahl ist eine ganze Zahl). Ich habe ein Problem damit, entweder 2 oder 3 Zweige für verschiedene Bedingungen zu haben. Hier ist mein Code:

import numpy as np 

class Node(object): 
    def __init__(self,number,parent): 
     self._parent = parent 
     self._number = number 
     self._satisfied = number > 100 or number == 6 or np.sqrt(number) % 1 == 0 
     self._branch1 = None 
     self._branch2 = None 
     self._branch3 = None 
     self._depth = parent.depth + 1 if parent != None else 1 

    @property 
    def parent(self): 
     return self._parent 

    @property 
    def number(self): 
     return self._number 

    @property 
    def satisfied(self): 
     return self._satisfied 

    @property 
    def depth(self): 
     return self._depth 

    @property 
    def branch1(self): 
     return self._branch1 

    @branch1.setter 
    def branch1(self,value): 
     self._branch1 = value 

    @property 
    def branch2(self): 
     return self._branch2 

    @branch2.setter 
    def branch2(self,value): 
     self._branch2 = value 

    @property 
    def branch3(self): 
     return self._branch3 

    @branch3.setter 
    def branch3(self,value): 
     self._branch3 = value 

def print_all_chains(node,chain=[]): 
    if node.branch1 is None: 
     chain.append(node.number) 
     print '{0}: {1}'.format(node.satisfied, chain) 
    else: 
     print_all_chains(node.branch1, chain[:] + [node.number]) 
     print_all_chains(node.branch2, chain[:] + [node.number]) 
     print_all_chains(node.branch3, chain[:] + [node.number]) 

def make_daughters(number): 
    if number % 2 == 0: #even 
     daughters = [number // 2, number * 2, number + 15] 
    else: 
     daughters = [number + 1, number * 4, None] 
    return daughters 

def build_tree(node, maxDepth): 
    if not node.satisfied and node.depth<maxDepth: 
     daughters = make_daughters(node.number) 
     node.branch1 = Node(daughters[0], node) 
     build_tree(node.branch1,maxDepth) 
     node.branch2 = Node(daughters[1], node) 
     build_tree(node.branch2,maxDepth) 
     node.branch3 = Node(daughters[2], node) 
     build_tree(node.branch3, maxDepth) 

def find_decay(number): 
    root = Node(number,None) 
    build_tree(root,maxDepth=3) 
    print_all_chains(root) 

if __name__ == '__main__': 
    find_decay(int(raw_input('Number: '))) 

Answer 1

Warum nicht eine Liste verwenden, um die Zweiginformationen zu halten? Dann kann es auf diese Weise neu geschrieben werden, ohne ein Keiner Typ Element in der Zwei-Zweig-Situation hinzuzufügen.

daughters = make_daughters(node.number) 
node.branch = [Node(d, node) for d in daughters] 

Ohne Sorgen über Keine Typ Elemente

Answer 2

Das Problem ist in den ungeraden Fall, wenn Sie make_daughters: Du bist ein None als dritter Parameter hinzufügen und später auf Sie erstellen ein Neu Node und versuchen Sie, die sqrt Methode auf None auszuführen.

Die folgenden Teile wurden geändert, um dieses Problem zu beheben:

def print_all_chains(node,chain=[]): 
    if node.branch1 is None: 
     chain.append(node.number) 
     print '{0}: {1}'.format(node.satisfied, chain) 
    else: 
     if node.branch1: # print only if it's a valid branch 
      print_all_chains(node.branch1, chain[:] + [node.number]) 
     if node.branch2: # print only if it's a valid branch 
      print_all_chains(node.branch2, chain[:] + [node.number]) 
     if node.branch3: # print only if it's a valid branch 
      print_all_chains(node.branch3, chain[:] + [node.number]) 

def make_daughters(number): 
    if number % 2 == 0: #even 
     daughters = [number // 2, number * 2, number + 15] 
    else: 
     daughters = [number + 1, number * 4] # don't send None 
    return daughters 

def build_tree(node, maxDepth): 
    if not node.satisfied and node.depth<maxDepth: 
     daughters = make_daughters(node.number) 
     node.branch1 = Node(daughters[0], node) 
     build_tree(node.branch1,maxDepth) 
     node.branch2 = Node(daughters[1], node) 
     build_tree(node.branch2,maxDepth) 
     if len(daughters) > 2: # make sure you have the third element 
      node.branch3 = Node(daughters[2], node) 
      build_tree(node.branch3, maxDepth)