识别树中的根父母及其所有孩子

Question

I have a pandas dataframe as such:

parent   child   parent_level   child_level
A        B       0              1
B        C       1              2
B        D       1              2
X        Y       0              2
X        D       0              2 
Y        Z       2              3

This represents a tree that looks like this

       A  X
      /  / \
     B  /   \
    /\ /     \
   C  D       Y
              |
              Z

I want to produce something that looks like this:

root    children
A       [B,C,D]
X       [D,Y,Z]

or

root   child
A      B
A      C
A      D
X      D
X      Y
X      Z 

What is the fastest way to do so without looping. I have a really large dataframe.

Answer 1

I suggest you use networkx , as this is a graph problem. In particular the descendants function:

import networkx as nx
import pandas as pd

data = [['A', 'B', 0, 1],
        ['B', 'C', 1, 2],
        ['B', 'D', 1, 2],
        ['X', 'Y', 0, 2],
        ['X', 'D', 0, 2],
        ['Y', 'Z', 2, 3]]

df = pd.DataFrame(data=data, columns=['parent', 'child', 'parent_level', 'child_level'])

roots = df.parent[df.parent_level.eq(0)].unique()
dg = nx.from_pandas_edgelist(df, source='parent', target='child', create_using=nx.DiGraph)

result = pd.DataFrame(data=[[root, nx.descendants(dg, root)] for root in roots], columns=['root', 'children'])
print(result)

Output

  root   children
0    A  {D, B, C}
1    X  {Z, Y, D}

Answer 2

With Recursion

def find_root(tree, child):
    if child in tree:
        return {p for x in tree[child] for p in find_root(tree, x)}
    else:
        return {child}

tree = {}
for parent, child in zip(df.parent, df.child):
    tree.setdefault(child, set()).add(parent)

descendents = {}
for child in tree:
    for parent in find_root(tree, child):
        descendents.setdefault(parent, set()).add(child)

pd.DataFrame(descendents.items(), columns=['root', 'children'])

  root   children
0    A  {B, D, C}
1    X  {Z, D, Y}

---

You could alternatively set up find_root as a generator

def find_root(tree, child):
    if child in tree:
        for x in tree[child]:
            yield from find_root(tree, x)
    else:
        yield child

Further, if you want to avoid recursion depth issues, you can use the "stack of iterators" pattern to define find_root

def find_root(tree, child):
    stack = [iter([child])]
    while stack:
        for node in stack[-1]:
            if node in tree:
                stack.append(iter(tree[node]))
            else:
                yield node
            break
        else:  # yes!  that is an `else` clause on a for loop
            stack.pop()

Answer 3

My approach is this, you start from the bottom-most parent_level and collect the children in a dictionary. As you go up, when you find that a parent in the dict is the child of another parent, you add those children to the new parent, then delete the old parent.

I've made a quick %time test, this method much faster (4.77 µs compared to 5.58 ms using networkx). Not too sure if it's the case when you scale up. You can give it a try.

import pandas as pd

data = [['A', 'B', 0, 1],
        ['B', 'C', 1, 2],
        ['B', 'D', 1, 2],
        ['X', 'Y', 0, 2],
        ['X', 'D', 0, 2],
        ['Y', 'Z', 2, 3]]

df = pd.DataFrame(data=data, columns=['parent', 'child', 'parent_level', 'child_level'])

current_roots = {}

for parent_level in range(df.parent_level.max(), -1, -1):
    children_to_remove_from_root = []

    for (root, rows) in df[df.parent_level == parent_level].groupby('parent'):
        children = rows['child'].values.tolist()
        current_roots[root] = children

        for child in children:
            if child in current_roots:
                current_roots[root] += current_roots[child]
                children_to_remove_from_root.append(child)


    for child in children_to_remove_from_root:
        del current_roots[child]

print(current_roots)