En supposant qu'il existe une et une seule valeur égale à 'S' , vous pouvez utiliser suivant :

['A', 'O', 'R', 'F']

Sortie

graph = [{'Node':'A', 'children':['T','Z','S'], 'gWt':[118,75,140], 'h':366},
         {'Node':'Z', 'children':['O','A'], 'gWt':[71,75], 'h':374},
         {'Node':'T', 'children':['A'], 'gWt':[118], 'h':329},
         {'Node':'S', 'children':['A','O','R','F'], 'gWt':[140,151,80,99], 'h':253}]

result = next(e for e in graph if e['Node'] == 'S')['children']
print(result)

J'ai l'impression que vos données sont dans le meilleur format possible, mais cela fait l'affaire:

 ['A', 'O', 'R', 'F']

sera imprimé

graph[[x['Node'] for x in graph].index('S')]['children']

p >

Commentaires sur l'utilisation de index () ou next () :

Création d'une liste des noms de nœuds puis recherche de l'index d'un nœud en utilisant le index () est la voie à suivre, mais notez que cela peut entraîner une dégradation considérable des performances ainsi que des erreurs logiques.

• Problèmes de performances: la recherche dans une liste à l'aide de list.index (cible) est O (n) , ce qui signifie qu'elle itère sur chaque élément de la liste jusqu'à ce qu'elle trouve le premier élément qui correspond à la cible qui n'est pas idéal.
• Erreurs de logique: si vous aviez un graphe mal formé, une liste contenant le même nom de nœud deux fois ou plus, par exemple: graph = [{"node": "A", ... props1}, { "node": "A", ... props2}] , vous ne rencontrerez que le premier nœud à cause de la nature de la fonction index () . Si vous voulez trouver tous les nœuds "A" , vous devrez exécuter index () sur toute la liste jusqu'à ce que vous soyez sûr d'avoir trouvé tous les nœuds "A" puis réfléchissez à une stratégie de fusion pour les propriétés des nœuds.

 Solution (recommandation):

Stockez les nœuds du graphe en utilisant un dictionnaire. Les dictionnaires ont des recherches en temps constant ( O (1) ) car ce sont des tables de hachage . La représentation que vous cherchez à obtenir est:

old_graph = [
    {'Node':'A', 'children':['T','Z','S'], 'gWt':[118,75,140], 'h':366},
    {'Node':'Z', 'children':['O','A'], 'gWt':[71,75], 'h':374},
    {'Node':'T', 'children':['A'], 'gWt':[118], 'h':329},
    {'Node':'S', 'children':['A','O','R','F'], 'gWt':[140,151,80,99], 'h':253}
]
new_graph = transform_graph(old_graph)
print(new_graph)

> {
    'A': {'children': {'S', 'T', 'Z'}, 'gWt': {75, 118, 140}, 'h': 366},
    'Z': {'children': {'A', 'O'}, 'gWt': {71, 75}, 'h': 374},
    'T': {'children': {'A'}, 'gWt': {118}, 'h': 329},
    'S': {'children': {'A', 'F', 'O', 'R'}, 'gWt': {80, 99, 140, 151}, 'h': 253}
}

Ce qui rendra également la traversée de votre graphe très facile. De cette façon, chaque fois que vous recherchez le nœud "X" , il vous suffit de graphe ["X"] pour l'obtenir, et graphe ["X" ] ["children"] pour obtenir ses enfants.

 Comment transformer l'entrée donnée en une structure de données optimale?

Si vous ne pouvez pas construire la structure de données mentionnée ci-dessus, vous voudrez définitivement le transformer en celui optimal si vous prévoyez d'interroger constamment les propriétés des nœuds du graphe. Vous pouvez y parvenir avec:

def transform_graph(graph):
    new_graph = {}
    for node in graph:
        node_name = node['Node']
        new_graph[node_name] = new_graph.get(
            node_name,
            {'children': set(), 'gWt': set(), 'h': 0}
        )
        new_graph[node_name]["children"] |= set(node['children'])
        new_graph[node_name]["gWt"] |= set(node["gWt"])
        new_graph[node_name]["h"] = node["h"]
    return new_graph

La sortie de l'appel de la fonction transform_graph (old_graph) est

graph = {
    "A": {'children':['T','Z','S'], 'gWt':[118,75,140], 'h':366},
    "B": {'children':['O','A'], 'gWt':[71,75], 'h':374},
    ...
}