PYTHON: Как создать список всех возможных сопоставлений букв с использованием словаря, который хранит все возможные комбинации сопоставления букв?

Question

Я работаю над программой, которая разбивает взаимно однозначные шифровальные шифры, где текущее состояние хранится в словаре, который содержит возможные сопоставления для каждой буквы. Каждый буквенный ключ содержит список букв, на которые он может быть сопоставлен. В конце концов, в списке каждой буквы должно быть только одно письмо. Для этой задачи, словарь будет выглядеть следующим образом с соответствующим: паром (ключ значения):

'A' : ['A'] 
'B' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'C' : ['C'] 
'D' : ['D'] 
'E' : ['E'] 
'F' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'G' : ['G', 'W'] 
'H' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'I' : ['I'] 
'J' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'K' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'L' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'M' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'N' : ['N'] 
'O' : ['O'] 
'P' : ['P'] 
'Q' : ['Q'] 
'R' : ['R'] 
'S' : ['S'] 
'T' : ['T'] 
'U' : ['U'] 
'V' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'W' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
'X' : ['X'] 
'Y' : ['Y'] 
'Z' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 

Как создать список, содержащий все возможные сопоставления ситуации в качестве элемента? Такой список будет содержать каждый возможный словарь, в котором каждый буквенный ключ имеет ровно одно значение букв в своем списке. Это позволило бы найти все возможные отображения с этим текущим состоянием. Пример элемент будет словарь:

'A' : ['A'] 
'B' : ['B'] 
'C' : ['C'] 
'D' : ['D'] 
'E' : ['E'] 
'F' : ['F'] 
'G' : ['G'] 
'H' : ['H'] 
'I' : ['I'] 
'J' : ['J'] 
'K' : ['K'] 
'L' : ['L'] 
'M' : ['M'] 
'N' : ['N'] 
'O' : ['O'] 
'P' : ['P'] 
'Q' : ['Q'] 
'R' : ['R'] 
'S' : ['S'] 
'T' : ['T'] 
'U' : ['U'] 
'V' : ['V'] 
'W' : ['W'] 
'X' : ['X'] 
'Y' : ['Y'] 
'Z' : ['Z'] 

Answer 1

EDIT: Я согласен с MRule. Всего было бы отображено 51 874 842 202 однобуквенных сопоставления. Рассмотрим следующий подход (в Python 2.7):

import itertools 
from collections import OrderedDict 
import string 
seed = { 
'A' : ['A'], 
'B' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'C' : ['C'], 
'D' : ['D'], 
'E' : ['E'], 
'F' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'G' : ['G', 'W'], 
'H' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'I' : ['I'], 
'J' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'K' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'L' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'M' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'N' : ['N'], 
'O' : ['O'], 
'P' : ['P'], 
'Q' : ['Q'], 
'R' : ['R'], 
'S' : ['S'], 
'T' : ['T'], 
'U' : ['U'], 
'V' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'W' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'], 
'X' : ['X'], 
'Y' : ['Y'], 
'Z' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
} 
d = OrderedDict(sorted(seed.items(), key=lambda t: t[0])) 
listOfList = d.values() 
for i in itertools.product(* listOfList): 
    # print the possible dict 
    print dict(zip(string.ascii_uppercase, i)) 

UPDATE:To only calculate the possible dictionaries where every mapped letter is unique, вы могли бы сделать:

import itertools 
import string 
others = ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
# this dict is fixed 
dict1 = {k : [k] for k in string.uppercase if k not in others} 
# iterate all possibles in others, then merge two dicts into one 
for i in itertools.permutations(others): 
    dict2 = dict(zip(others, i)) 
    print dict(dict1.items() + dict2.items())