根据 dict 给定的依赖关系，用序列迭代列表

Question

I have a list lst and I want to iteratively transform each element in the list using a function f :

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

def f(x):
    # do something
    return x

I can iteratively apply this transformation over the list:

new_lst = [f(x) for x in lst]

So far so good. Now we want to introduce sequencing for processing elements in the lst . The dict ensure_transformed describes a list of elements that need to be transformed before processing a given element:

ensure_transformed = {'a' : ['b', 'e'],
                      'b' : ['e', 'f'],
                      'c' : ['a', 'd'],
                      'd' : [],
                      'e' : [],
                      'f' : []
                      }

The interpretation is - Before transforming a , transform b and e , before transforming b , transform e and f and so on.

(The meaning of 'd': [] is that no elements need to be processed before d . g is absent from ensure_transformed implying g shouldn't be transformed.)

How can I transform lst using function f while ensuring sequencing from ensure_transformed ?

Options on the table:

1. Use recursion to go through list while keeping track of elements that have already been transformed. This approach has become messy to manage.

2. Re-order the list using the dict and then iterate over the list. I haven't tried this approach yet, but it seems promising.

I'm open to other approaches.

Answer 1

The ensure_transformed dictionary describes a directed graph where {'a': ['b', 'e']} means that there is an edge b → a and an edge e → a .

Assuming that the graph has no cycles, your task is equivalent to applying topological sorting to it, for which you can find various algorithms.

Answer 2

As mentioned by @CristianCiupitu in the comments, this is now very easy to do with Python 3.9 by using thegraphlib module:

import graphlib
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

def f(x): return x.upper() #for example

ensure_transformed = {'a' : ['b', 'e'],
                      'b' : ['e', 'f'],
                      'c' : ['a', 'd'],
                      'd' : [],
                      'e' : [],
                      'f' : []
                      }

ts = graphlib.TopologicalSorter(ensure_transformed)

processed = [f(x) for x in ts.static_order()]
print(processed)
#prints ['E', 'F', 'D', 'B', 'A', 'C']