Why won't my Python function be recursive/call itself?

Question

I am making a String Rewriting Function that takes a string and rewrites it according to the rules in a dictionary. The code works perfectly fine once but I need it to call itself n times and print the 'nth' rewritten string. The code that works that I need to be recursive is:

S = "AB"
def srs_print(S, n, rules):
    '''
    A function that takes a dictionary as SRS rules and prints
    the output
    '''
    axiom = list(S)
    key =  []
    value = []
    output = ''

    for k in rules:
        #Inputs the keys of the rules dictionary into a new list
        key.append(k)
        #Inputs the value of the rules dictionary into a new list
        value.append(rules[k])

    for x in axiom:
        if x in key:
            axiomindex = key.index(x)
            output += value[axiomindex]
       else:
            output += x
    S = output
    return S
#j  =  srs_print(S, 5, {'A':'AB', 'B': 'A'})
#print(j)

#while len(range(n))  > 0:
#   S = srs_print(S, n, rules)
#   n = n-1
#print("The", n, "th rewrite is " )

#j = srs_print(S, 5, {'A':'AB', 'B': 'A'})
print(srs_print("A", 5, {'A':'AB', 'B': 'A'}))

This turns "A" into "AB" but I need it to put 'S' back into the function and run again 'n'times. As you can see, some of the commented code are lines I have tried to use but have failed.

I hope I've explained myself well enough.

Answer 1

If I understand correctly, you pass "n" to the function as a way to count how many times you need to call it.

You could probably get away with enclosing the whole body of the function in a for or a while loop. If you want it to be recursive anyway, here's how it could work:

You need to have "two" return statements for your function. One that returns the result (in your case, "S"), and another one, that returns srs_print(S, n-1, rules) Ex:

if n > 0:
    return srs_print(S, n-1, rules)
else:
    return S

I suggest you take some time and read this , to get a better understanding of what you want to do and whether or not it is what you should do.

Answer 2

You definitly don't need recursion here. First let's rewrite your function in a more pythonic way:

def srs_transform(string, rules):
    '''
    A function that takes a dictionary as SRS rules and prints
    the output
    '''

    # the short way:
    # return "".join(rules.get(letter, letter) for letter in string)


    # the long way
    output = []
    for letter in string:
        transformed = rules.get(letter, letter)
        output.append(transformed)
    return "".join(output)

Now we add a wrapper function that will take care of applying srs_transform a given number of times to it's arguments:

def srs_multi_transform(string, rules, times):
    output = string
    for x in range(times):
        output = srs_transform(output, rules)
    return output

And now we just have to call it:

print(srs_transform("A",  {'A':'AB', 'B': 'A'}, 5))

>> ABAABABAABAAB

Answer 3

Why not simply use a for -loop?

def srs_print(S, n, rules):
    for _ in range(n):
        S = ''.join(rules.get(x, x) for x in S)
    return S