搜索并用数字替换字典查找中的列表

Question

UPDATE I see I wasn't clear on the original question. Given a list

last_eqn=[[3], [2, 1]]

and a list dictionary:

{2: [[5], [3, 1]],
3: [[8], [5, 1]],
5: [[13], [8, 1]],
8: [[21], [13, 1]],
13: [[34], [21, 1]],
21: [[55], [34, 1]],
34: [[89], [55, 1]]}

Substitute for every number in last_eqn, with the value of the key if key==number in the last_eqn. For Eg:

[[3], [2, 1]] = [[[[8], [5, 1]]], [2, 1]] = 
[[[[8], [[[13], [8, 1]], 1]]], [2, 1]] = 
[[[[[[21], [13, 1]]], [[[13], [[[21], [13, 1]], 1]], 1]]], [2, 1]]

---

I have an initial list:

last_eqn=[[3], [2, 1]]

and a dictionary frame

{2: [[5], [3, 1]],
3: [[8], [5, 1]],
5: [[13], [8, 1]],
8: [[21], [13, 1]],
13: [[34], [21, 1]],
21: [[55], [34, 1]],
34: [[89], [55, 1]]}

I want to substitute the values of numbers in last_eqn till all the numbers boil down to the last (here they will be in terms of 89 and 55) That is the structure of each list.

I wrote this:

def recur_subs(last_eqn,frame=frame):
    """
    {2: [[5], [3, 1]],
    3: [[8], [5, 1]],
    5: [[13], [8, 1]],
    8: [[21], [13, 1]],
    13: [[34], [21, 1]],
    21: [[55], [34, 1]],
    34: [[89], [55, 1]]}
    """
    for key in frame:
        fst,scnd = last_eqn
        fst_num,scnd_num=fst[0],scnd[0]
        #fst_marker,scnd_marker = 0,0
        while not isinstance(fst_num,int):
            #fst_marker += 1
            fst_num = fst_num[0] 
        while not isinstance(scnd_num,int):
            #scnd_marker += 1
            scnd_num = scnd_num[0]
        print fst_num,scnd_num
        if isinstance(fst_num,int) and fst_num in frame:
            fst[0] = (frame[fst_num])
        if isinstance(scnd_num,int) and scnd_num in frame: 
            scnd[0] = (frame[scnd_num])
        last_eqn = [fst,scnd]
        print last_eqn

It doesn't solve properly. Im trying to correct it but here's the output:

recur_subs(last_eqn,frame)
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]
55 89
[[[[55], [34, 1]]], [[[89], [55, 1]], 1]]

This is slow but I want to get down to the correct way of solving it. The values should be searched and substituted properly going down till [[89], [55, 1]]

Answer 1

I don't fully understand your algorithm, but I made a guess, which could be wrong. How about something like this?

def my_substitution(last_equation, frame=frame):
   while True:
       key = last_equation[1][0]
       print last_equation
       if key in frame:
           last_equation = frame[key]
       else:
           break
   print last_equation

Output:

[[3], [2, 1]]
[[5], [3, 1]]
[[8], [5, 1]]
[[13], [8, 1]]
[[21], [13, 1]]
[[34], [21, 1]]
[[55], [34, 1]]
[[89], [55, 1]]
[[89], [55, 1]]

Update

Let me make sure that I understand your algorithm correctly.

1. Let's start out trying to substitute just once. I named my function substitute_once() .

2. For substitute_once() , let's try the simplest input:

    >>> substitute_once(2) [[5], [3, 1]] 

3. If the input is a list, then substitute_once() will call itself recursively for each element:

    >>> substitute_once([[3], [2, 1]]) [[[[8], [5, 1]]], [[[5], [3, 1]], 1]] 

   This is because we replace both the 3 with [[8], [5, 1]] and 2 with [[5], [3, 1]]

4. Assume that we know how to replace it once, we can do it repeatedly until we can no longer replace. In other word, substitute_once(the_list) == the_list .

If my assumptions are correct, then here is how I would do it:

def substitute_once(n, frame=frame):
    if isinstance(n, list):
        return [substitute_once(x) for x in n]
    if n in frame:
        return frame[n]
    else:
        return n

def substitute_recursively(last_equation,frame=frame):
    while True:
        new_equation = substitute_once(last_equation)
        print new_equation
        if new_equation == last_equation:
            break
        last_equation = new_equation

Discussion

• substitutte_once() is straight-forward, as I have discussed it in bullet points 1-3 above.
• substitute_recursively() is equally simple because we only solve a small problem: just call substitute_once() repeatedly until the new list and old are the same, meaning we can no longer make any substitution.

The final output is so long, I don't see any point showing it. Please let me know if this is what you want.

Answer 2

Since you want to recursively substitute those items, you have to call, at some point, the substitution function in itself. In the recurs_subs function, I replace every first number of the lists in last_eqn by the corresponding list of lists in the dictionary, in which I have substituted numbers too, by passing them to recurs_subs first.

import copy

def recur_subs(last_eqn, frame):
    for item in last_eqn:
        if type(item[0]) == int and item[0] in frame:
            substitute = copy.deepcopy(frame[item[0]])
            item[0] = recur_subs(substitute, frame)

    return last_eqn

Output:

[[[[[[[[55], [[[89], [55, 1]], 1]]], [[[[[89], [55, 1]]], [[[55],[[[89],
[55, 1]], 1]], 1]], 1]]], [[[[[[[89], [55, 1]]], [[[55], [[[89], [55, 1]], 1]],
1]]], [[[[[55], [[[89], [55, 1]], 1]]], [[[[[89], [55, 1]]], [[[55], [[[89],
[55, 1]], 1]], 1]], 1]], 1]], 1]]], [[[[[[[[[89], [55, 1]]], [[[55], [[[89],
[55, 1]], 1]], 1]]], [[[[[55], [[[89], [55, 1]], 1]]], [[[[[89], [55, 1]]],
[[[55], [[[89], [55, 1]], 1]], 1]], 1]], 1]]], [[[[[[[55], [[[89], [55, 1]],
1]]], [[[[[89], [55, 1]]], [[[55], [[[89], [55, 1]], 1]], 1]], 1]]],
[[[[[[[89], [55, 1]]], [[[55], [[[89], [55, 1]], 1]], 1]]], [[[[[55],
[[[89], [55, 1]], 1]]], [[[[[89], [55, 1]]], [[[55], [[[89], [55, 1]], 1]],
1]], 1]], 1]], 1]], 1]], 1]]

As you can see, I also decided to copy the list of lists to prevent modifying objects stored in the list dictionary.

But maybe you want those objects to be modified, since the substitutions would be the same anyway. It would probably make the substitutions faster, since the substitution for a 2 would be stored in memory instead of computed at every 2 encountered, and so on for every substituted numbers.

If this is the case, just remove the deep copy and directly pass frame[item[0]] to recurs_subs .

Answer 3

Recursively substitute each element in the list (of list of list of list...)

def recsub( last_eqn ):

    if type(last_eqn) != list:
        if last_eqn in repdic:
            last_eqn = repdic[last_eqn]
    else:
        for i in range(len(last_eqn)):
            last_eqn[i] = recsub( last_eqn[i] )

    return last_eqn

And check if the new list is same as the old list. You need a deepcopy operation for this.

last_eqn=[[3], [2, 1]]
A = last_eqn
B = 0

import copy

while 1:
    recsub(A)
    if A==B:
        break
    else:
        B=copy.deepcopy(A)

Answer 4

UPDATE

I agree with Hai Vu's,Fury's,ysakamoto's answers. With Hai's, functions were clearly broken down very well. Fury's was more inherently in nature and concise though. I modified my recur_subs code and I did a compare with all answers here:

last_eqn=[[3], [2, 1]]

%timeit recsub(last_eqn) #ysakomoto's
10000 loops, best of 3: 174 µs per loop

%timeit recur_subs(last_eqn,frame) #mine
10000 loops, best of 3: 168 µs per loop

%timeit recur_subs2(last_eqn,frame) #Fury's
1000000 loops, best of 3: 578 ns per loop

ie 0.578 micro-sec /loop

%timeit substitute_recursively(last_eqn,frame) #Hai Vu's
1000 loops, best of 3: 361 µs per loop

%timeit substitute_recursively(last_eqn,frame) #Hai Vu's No Print just return
10000 loops, best of 3: 145 µs per loop

And here's my code:

def recur_subs(last_eqn,frame=frame):
    """
    last_eqn=[[3], [2, 1]]
    {2: [[5], [3, 1]],
    3: [[8], [5, 1]],
    5: [[13], [8, 1]],
    8: [[21], [13, 1]],
    13: [[34], [21, 1]],
    21: [[55], [34, 1]],
    34: [[89], [55, 1]]}
    """
    for enum,lst_item in enumerate(last_eqn):
        if isinstance(lst_item,int):
            if lst_item in frame:
                last_eqn[enum] = recur_subs(frame[lst_item])
        elif isinstance(lst_item,list): lst_item = recur_subs(lst_item)
    return last_eqn

If I'm correct Fury's code executes fastest to slowest: Fury's > Hai Vu's(no print) > mine > ysakomoto's