Python: Maximale Rekursionstiefe überschritten

Ich habe den folgenden Rekursionscode. An jedem Knoten rufe ich eine SQL-Abfrage auf, um festzustellen, ob die Knoten zum übergeordneten Knoten gehören.

Hier ist der Fehler:

Exception RuntimeError: 'maximum recursion depth exceeded' in <bound method DictCursor.__del__ of <MySQLdb.cursors.DictCursor object at 0x879768c>> ignored

RuntimeError: maximum recursion depth exceeded while calling a Python object
Exception AttributeError: "'DictCursor' object has no attribute 'connection'" in <bound method DictCursor.__del__ of <MySQLdb.cursors.DictCursor object at 0x879776c>> ignored

Methode, die ich aufrufe, um SQL-Ergebnisse zu erhalten:

def returnCategoryQuery(query, variables={}):
    cursor = db.cursor(cursors.DictCursor);
    catResults = [];
    try:
        cursor.execute(query, variables);
        for categoryRow in cursor.fetchall():
            catResults.append(categoryRow['cl_to']);
        return catResults;
    except Exception, e:
        traceback.print_exc();

Ich habe eigentlich kein Problem mit der obigen Methode, aber ich habe es trotzdem ausgedrückt, um einen angemessenen Überblick über die Frage zu geben.

Rekursionscode:

def leaves(first, path=[]):
    if first:
        for elem in first:
            if elem.lower() != 'someString'.lower():
                if elem not in path:
                    queryVariable = {'title': elem}
                    for sublist in leaves(returnCategoryQuery(categoryQuery, variables=queryVariable)):
                        path.append(sublist)
                        yield sublist
                    yield elem

Aufruf der rekursiven Funktion

for key, value in idTitleDictionary.iteritems():
    for startCategory in value[0]:
        print startCategory + " ==== Start Category";
        categoryResults = [];
        try:
            categoryRow = "";
            baseCategoryTree[startCategory] = [];
            #print categoryQuery % {'title': startCategory};
            cursor.execute(categoryQuery, {'title': startCategory});
            done = False;
            while not done:
                categoryRow = cursor.fetchone();
                if not categoryRow:
                    done = True;
                    continue;
                rowValue = categoryRow['cl_to'];
                categoryResults.append(rowValue);
        except Exception, e:
            traceback.print_exc();
        try:
            print "Printing depth " + str(depth);
            baseCategoryTree[startCategory].append(leaves(categoryResults))
        except Exception, e:
            traceback.print_exc();

Code zum Drucken des Wörterbuchs,

print "---Printing-------"
for key, value in baseCategoryTree.iteritems():
    print key,
    for elem in value[0]:
        print elem + ',';
    raw_input("Press Enter to continue...")
    print

Wenn die Rekursion zu tief ist, sollte der Fehler angezeigt werden, wenn ich meine Rekursionsfunktion aufrufe, aber wenn ich diesen Fehler erhalte, wenn ich das Wörterbuch drucke.

Sie können die zulässige Stapeltiefe erhöhen. Auf diese Weise sind tiefere rekursive Aufrufe wie folgt möglich:

import sys
sys.setrecursionlimit(10000) # 10000 is an example, try with different values

... Aber ich würde Ihnen raten, zuerst zu versuchen, Ihren Code zu optimieren, indem Sie beispielsweise Iteration anstelle von Rekursion verwenden.