Как создать общий список значений из словаря

Question

В настоящее время я Dict, что я хочу, чтобы создать окончательный полный список ключей и значений из:

adict = {'f': {'g', 'd'}, 
     'd': {'g'}, 
     'e': {'d'}, 
     'b': {'d'}, 
     'c': {'f', 'e'}, 
     'a': {'b', 'c'}} 

В настоящее время я ищу, функции в этом формат:

def create_final_total_list(thedictionary: dict(), startingkey:str): 
    final_list = [] 
    # function here 

То, что я хочу, чтобы пользователь ввел ключ запуска, который присоединяет ключ и его значение в final_list. И эти значения также становятся ключами, которые также добавят все их значения в final_list и так далее.

Примера, если стартовый ключ будет «а», то первым делает:

final_list = ['a', 'b', 'c'] 

Тогда было бы увидеть «B» и значение «C» и добавить их значения из Словаря чтобы она стала:

final_list = ['a', 'b', 'c', 
       'b', 'd', 
       'c', 'f', 'e', ...] 

а из значений 'г', 'е' и 'е' он стал бы:

final_list = ['a', 'b', 'c', 

       'b', 'd', 
       'c', 'f', 'e' 

       'd', 'g' 
       'f', 'g', 'd' 
       'e', 'd' ...] 

и так далее ...

Его вид как функция достижения, которая достигает от одного ключа и от его значений, до следующего.

Как подойти к этому в Python 3.3?

Answer 1

Как о следующем:

Использование deque в очереди:

>>> from topsort import adict, create_final_total_list 
>>> adict 
{'a': {'b', 'c'}, 'b': {'d'}, 'c': {'e', 'f'}, 'd': {'g'}, 'e': {'d'}, 'f': {'d', 'g'}} 
>>> create_final_total_list(adict, 'c') 
['c', 'e', 'f', 'f', 'd', 'g', 'g', 'd', 'g', 'g', 'e', 'd', 'd', 'g', 'g'] 

Код функции:

def create_final_total_list(the_dict, startingkey): 
    final_list = [] 
    var = deque([startingkey]) 
    while var: 
     u = var.pop() 
     final_list.append(u) 
     s = the_dict[u] if u in the_dict else None 
     if s: 
      final_list.extend(s) 
      var.extend(s) 

    return final_list 

Answer 2

Я изменил свой первый словарь, так что он содержит Dict из списков (иначе синтаксис не был прав), то я просто передал ваш окончательный список в качестве выходного параметра:

>>> adict = {'f': ['g', 'd'], 
     'd': ['g'], 
     'e': ['d'], 
     'b': ['d'], 
     'c': ['f', 'e'], 
     'a': ['b', 'c']} 
>>> def create_final_total_list(thedictionary, startingkey, final_list): 
    final_list.append(startingkey) 
    final_list.extend(thedictionary[startingkey]) 


>>> fl = [] 
>>> create_final_total_list(adict, 'a', fl) 
>>> fl 
['a', 'b', 'c'] 
>>> create_final_total_list(adict, 'b', fl) 
>>> create_final_total_list(adict, 'c', fl) 
>>> fl 
['a', 'b', 'c', 'b', 'd', 'c', 'f', 'e'] 
>>> 

Answer 3

Я вижу опубликованный ответ, поэтому я буду в любом случае опубликовать сообщение. Моя реализация очереди была просто список, хотя и не уверен, будет ли какое-либо преимущество в использовании очереди или dqueue

Реализация

def create_final_total_list(thedictionary, key): 
    final_list = list(thedictionary[key]) 
    Q = list(thedictionary[key]) 
    while Q: 
     key = Q.pop(0) 
     final_list+=thedictionary.get(key, []) 
     Q+=thedictionary.get(key, []) 
    return final_list 

Выход

>>> create_final_total_list(adict, 'a') 
['c', 'b', 'e', 'f', 'd', 'd', 'd', 'g', 'g', 'g', 'g'] 

Answer 4

рекурсивная реализация может быть:

from itertools import chain 

adict = {'f': {'g', 'd'}, 
     'd': {'g'}, 
     'e': {'d'}, 
     'b': {'d'}, 
     'c': {'f', 'e'}, 
     'a': {'b', 'c'}} 

def create_final_list(dict_, key): 
    values = list(dict_.get(key, [])) 
    return [key] + values + \ 
     list(chain(*[create_final_list(dict_, v) for v in values])) 

print create_final_list(adict, "a") 

Это печатает:

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

Пожалуйста, обратите внимание, что порядок элементов в наборе {"a","b"} не является фиксированным, таким образом, порядок может изменяться.