I keep getting this error:RecursionError: maximum recursion depth exceeded while calling a Python object

Question

I am trying to use BFS to search through a tree with three letter words and find the way in between a given start and end word and print the way in between. The printing is supposed to be done with a recursive function.

I keep getting this error:

RecursionError: maximum recursion depth exceeded while calling a Python object

and an infinite loop with the endword can anyone see whats wrong? (I copied my imported classes as well).

from array import array

class Node1:

#håller koll på värdena

    def __init__(self, data, next = None):
        self.data = data
        self.next = next

    def __str__(self):
        if self.data.parent == None:
            return None

        else:
            print(self.data.parent)
            return str(self.data.parent)

    def __str__(self):
        return str(self.data.word)

class Queue:

    def __init__(self):
       self.first = None
       self.last = None

    def enqueue(self,x):
        """Stoppar in x sist i kön """
        x = Node1(x)

        if self.first == None:  # Om kön är tom
            self.first = self.last = x

        else:                   # om kön inte är tom
            self.last.next = x
            self.last = x

    def dequeue(self):
        first = self.first
        self.first = self.first.next
        #if self.first == None:
        #    self.last=None
        return first

    def isEmpty(self):
        if self.first == None:
            xx = True
        else:
            xx = False
            #print('I IsEmpty: Första elementet i listan:',self.first)
            #print('I IsEmpty: Sista elementet i listan:',self.last)

        return xx


    def __str__(self):
        node=self.first
        node_strang = 'Efter trolleriet får man: ' 
        while node != None:
            node_strang += str(node)
            node = node.next
        return node_strang

class Node:
    '''Nodklass med rekursiva metoder som anropas i Bintree-klassen'''

    def __init__(self, word):
        self.word = word
        self.left = None
        self.right = None

    def insert(self, new_word):
        if self.word == new_word:
            return False
        elif new_word < self.word:
            if self.left:
                return self.left.insert(new_word)
            else:
                self.left = Node(new_word)
                return True
        else:
            if self.right:
                return self.right.insert(new_word)
            else:
                self.right = Node(new_word)
                return True

    def find(self, new_word):
        if self.word == new_word:
            return True
        elif new_word < self.word:
            if self.left:
                return self.left.find(new_word)
            else:
                return False
        else:
            if self.right:
                return self.right.find(new_word)
            else:
                return False

    def preorder(self):
        if self:
            print(self.word)
            if self.left:
                self.left.preorder()
            if self.right:
                self.right.preorder()

    def postorder(self):
        if self:
            if self.left:
                self.left.postorder()
            if self.right:
                self.right.postorder()
            print(self.word)

    def inorder(self):
        if self:
            if self.left:
                self.left.inorder()
            print(self.word)
            if self.right:
                self.right.inorder()

from linkedQFile import Queue,Node1
from bintreeFile import Node
import string

class Bintree:
    def __init__(self):
        self.root = None

    def put(self, new_word):
        if self.root:
            return self.root.insert(new_word)
        else:
            self.root = Node(new_word)
            return True

    def __contains__(self, new_word):
        if self.root:
            return self.root.find(new_word)
        else:
            return False

class ParentNode:
    def __init__(self, word, parent = None):
        self.word = word
        self.parent = parent


def maketree():
    svenska = Bintree()
    gamla = Bintree()

    with open('word3.txt', 'r') as ordfil:
        for rad in ordfil:
            ord = rad.strip()
            if ord in svenska:
                gamla.put(ord)
            svenska.put(ord)

        ordfil.close()
    return svenska,gamla

def writechain(kidzen, paronen):

    if paronen is not None:
        print(kidzen)
        writechain(kidzen, paronen)
    else:
        pass

def countchain(barn_obj):
    if barn_obj.parent==None:
        return 0
    else:
        return 1+countchain(barn_obj.parent)


def makechildren(nod, q, gamla, svenska):
    for i in range(3):
        bokstavslista = list(nod.data.word)
        alfabetslista = list(string.ascii_lowercase) + ['å', 'ä', 'ö']

        for bokstav in alfabetslista:
            bokstavslista[i] = bokstav
            barn = ''.join(bokstavslista)

            if barn in svenska:
                barn_obj = ParentNode(barn, nod.data)
                #print('parent to', barn, 'is', str(barn_obj.parent))
                if barn not in gamla:
                    #print("i makechildren: barn = ", barn)
                    q.enqueue(barn_obj)
                    gamla.put(barn_obj.word)
def main():

    (svenska,gamla) = maketree()
    q=Queue()

    start = input('Startord:')
    slut = input('Slutord:')

    startord= ParentNode(start, parent=None)
    q.enqueue(startord)

    while not q.isEmpty():

        nod = q.dequeue()
        makechildren(nod, q, gamla, svenska)
        nod_for=nod.data
        kidzen=nod_for.word
        paronen=nod_for.parent
        #print ('word =', kidzen)
        #print ('parent =', paronen)


        if q.isEmpty():
            print('Det finns ingen väg till', slut)
            break

        elif kidzen==slut:
            writechain(kidzen, paronen)
            print('Det finns en väg till', slut)
            break

main()

Answer 1

In your writechain function you are not walking a tree.

You keep recursively calling it with the same arguments. That will continue until you reach the recursion limit.