Python-在嵌套列表中查找所有列表

Question

I am working on my own implementation of genetic programming (GP) in Python. GP aims at evolving programs, represented as LISP S-expressions, to search for a good solution to a problem.

S-expressions use prefix notation. For instance:

(+ (- 1 2) (- 3 (/ 4 5)))

This expression is equivalent to the following in infix algebra.

(1 - 2) + (3 - 4 / 5)

I am using Peter Norvig's LISP interpreter (lispy) to parse and evaluate these expressions. The parser converts expressions to nested lists. The above expression would for instance be represented as:

['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]

Peter Norvig's code (from which I removed operators that I do not need):

#lispy.py (Peter Norvig)

Symbol = str

def read(s):
    "Read a Scheme expression from a string."
    return read_from(tokenize(s))

parse = read

def tokenize(s):
    "Convert a string into a list of tokens."
    return s.replace('(',' ( ').replace(')',' ) ').split()

def read_from(tokens):
    "Read an expression from a sequence of tokens."
    if len(tokens) == 0:
        raise SyntaxError('unexpected EOF while reading')
    token = tokens.pop(0)
    if '(' == token:
        L = []
        while tokens[0] != ')':
            L.append(read_from(tokens))
        tokens.pop(0) # pop off ')'
        return L
    elif ')' == token:
        raise SyntaxError('unexpected )')
    else:
        return atom(token)

def atom(token):
    "Numbers become numbers; every other token is a symbol."
    try: return int(token)
    except ValueError:
        try: return float(token)
        except ValueError:
            return Symbol(token)

I now need to write functions to mate and mutate expressions. These genetic operations may occur at any position in the list. The above expression could be mutated by changing either the whole list (at root), or by changing any of its sub-expressions (lists) or terminals (list element other than the operator). The mutation could therefore be performed on any of the following:

['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]
['-', 1, 2]
['-', 3, ['/', 4, 5]]
['/', 4, 5]
1
2
3
4
5

I therefore think the next step to write a function that takes a nested list as an argument and returns a list of all lists, nested lists and terminals (other than operators) that its contains. I would then randomly pick an element of the resulting new list and mutate it or swap it with the component of another expression.

I have written the code below, but it does not work as expected (see terminal output at the bottom). I am not very comfortable with recursion yet. Could anyone help pinpoint what I am doing wrong? (Note: the global variable is only for the purpose of trying to understand how recursion works)

from copy import deepcopy

global counter
counter = 0

def decompose_expr(list_in, operators, list_out=[], iter=0):
    global counter
    counter += 1
    print(str(counter) + ' list_out=' + str(list_out))
    if (len(list_in) != 0):
        if iter ==0:
            print(str(counter) + ' appending:' + str(list_in))
            list_out.append(deepcopy(list_in))
        print(str(counter) + ' list_out after appending:' + str(list_out))
        print(str(counter) + ' length of list_out after appending:' + str(len(list_out)))
        print(str(counter) + ' popping:' + str(list_in[0]))
        elem = list_in[0]
        if (type(elem) == list):
            print(str(counter) + ' appending:' + str(elem))
            list_out.append(deepcopy(elem))
        if (type(elem) != list and elem not in operators):
            print(str(counter) + ' appending:' + str(elem))
            list_out.append(elem)
        list_in.pop(0)
        print(str(counter) + ' recursion: list in is' + str(list_in) + ' list_out is ' + str(list_out) + '\n')
        iter += 1
        decompose_expr(list_in, operators, list_out)
        return list_out

operators = ['+', '-', '/', '*', '<', '>']

expr = '(+ (- 1 2) (- 3 (/ 4 5)))'

expr_representation = parse(expr)
print(expr_representation)
print(str(expr))
print('')

list_out = decompose_expr(expr_representation, operators)
print('\nThe result is:')
if list_out != None:
    for item in list_out:
        print(str(item))
else:
    print 'empty :('

The result I expect is:

[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2], ['-', 3, ['/', 4, 5]], ['/', 4, 5], 1, 2, 3, 4 5]

But here is the result I get:

[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2], [['-', 3, ['/', 4, 5]]], ['-', 3, ['/', 4, 5]]]

And here is the terminal output:

['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]
(+ (- 1 2) (- 3 (/ 4 5)))

1 list_out=[]
1 appending:['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]
1 list_out after appending:[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]]
1 length of list_out after appending:1
1 popping:+
1 recursion: list in is[['-', 1, 2], ['-', 3, ['/', 4, 5]]] list_out is [['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]]

2 list_out=[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]]
2 appending:[['-', 1, 2], ['-', 3, ['/', 4, 5]]]
2 list_out after appending:[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]]]
2 length of list_out after appending:2
2 popping:['-', 1, 2]
2 appending:['-', 1, 2]
2 recursion: list in is[['-', 3, ['/', 4, 5]]] list_out is [['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2]]

3 list_out=[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2]]
3 appending:[['-', 3, ['/', 4, 5]]]
3 list_out after appending:[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2], [['-', 3, ['/', 4, 5]]]]
3 length of list_out after appending:4
3 popping:['-', 3, ['/', 4, 5]]
3 appending:['-', 3, ['/', 4, 5]]
3 recursion: list in is[] list_out is [['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2], [['-', 3, ['/', 4, 5]]], ['-', 3, ['/', 4, 5]]]

4 list_out=[['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]], [['-', 1, 2], ['-', 3, ['/', 4, 5]]], ['-', 1, 2], [['-', 3, ['/', 4, 5]]], ['-', 3, ['/', 4, 5]]]

The result is:
['+', ['-', 1, 2], ['-', 3, ['/', 4, 5]]]
[['-', 1, 2], ['-', 3, ['/', 4, 5]]]
['-', 1, 2]
[['-', 3, ['/', 4, 5]]]
['-', 3, ['/', 4, 5]]

Thanks, LC

Answer 1

I have found this solution:

def decompose_expr(list_in, operators, list_out=[], iter=0):

    if (len(list_in) != 0):
        if iter == 0:
            list_out.append(deepcopy(list_in))
        iter += 1
        if (type(list_in) == list):
            for elem in list_in:
                if elem not in operators:
                    list_out.append(deepcopy(elem))
                if (type(elem) == list):
                    decompose_expr(elem, operators, list_out, iter)
        else:
            if list_in not in operators:
                list_out.append(list_in)
    return list_out