Question

我正在为我的问题寻找一个不错的pythonic解决方案。我有这样的字典：

char_dist = {'b' : 0.345, 'd' : 0.158, 'c' : 0.059, 'w' : 0.437}

我想得到这样的东西：

new_dict = {'b': {'b': 0.11902,
                  'd': 0.05451,
                  'c': 0.020355,
                  'w': 0.150765},
            'd': {'b': 0.054501,
                  'd': 0.024964,
                  'c': 0.009322,
                  'w': 0.150765},
            'c': {'b': 0.020355,
                  'd': 0.009322,
                  'c': 0.003481,
                  'w': 0.025783},
            'w': {'b': 0.150765,
                  'd': 0.069046,
                  'c': 0.025783,
                  'w': 0.190969}}

新字典是旧字典中的值相乘的结果。

new_dict = {char_dist[key] : {char_dist[key1]: char_dist[key1][value] * char_dist[key2][value], etc...

P.S。我尝试过这样的方法，但仍然可以解决：

new = defaultdict(dict)

for base, val in char_distribution.items():
    new[base] = {base: p for base, p in
                     zip('bdcw', char_dist)}


pprint(matrix)

但是对于所有嵌套字典，我都得到了相同的值：

defaultdict(<class 'dict'>,
            {'b': {'b': 0.11902,
              'd': 0.05451,
              'c': 0.020355,
              'w': 0.150765},
             'c': {'b': 0.11902,
              'd': 0.05451,
              'c': 0.020355,
              'w': 0.150765}
            'd': {'b': 0.11902,
              'd': 0.05451,
              'c': 0.020355,
              'w': 0.150765}
             'w': {'b': 0.11902,
              'd': 0.05451,
              'c': 0.020355,
              'w': 0.150765}})

我想创建一种过渡矩阵。

Answer 1

您可以通过嵌套字典理解来做到这一点：

expected = {kk: {k: vv*v for k, v in char_dist.items()} for kk, vv in char_dist.items()}

print(expected)
[out]:
{'b': {'b': 0.11902, 'c': 0.02035, 'd': 0.05451, 'w': 0.15076},
 'c': {'b': 0.02035, 'c': 0.00348, 'd': 0.00932, 'w': 0.02578},
 'd': {'b': 0.05451, 'c': 0.00932, 'd': 0.02496, 'w': 0.06905},
 'w': {'b': 0.15076, 'c': 0.02578, 'd': 0.06905, 'w': 0.19097}}

Answer 2

我想，如果您要处理分布，那么一些线性代数就不会有问题。认识熊猫：

import pandas as pd
....
df = pd.DataFrame([char_dist])
df.T.dot(df)

输出：

          b         d         c         w
b  0.119025  0.054510  0.020355  0.150765
d  0.054510  0.024964  0.009322  0.069046
c  0.020355  0.009322  0.003481  0.025783
w  0.150765  0.069046  0.025783  0.190969

Answer 3

我认为最简单：

char_dist = {'b': 0.345, 'd': 0.158, 'c': 0.059, 'w': 0.437}
old_dict = {'b': 0.68746258423, 'd': 0.5429823052, 'c': 0.5849805243, 'w': 0.95840285}

new_dict = dict.fromkeys(char_dist, old_dict)

print(new_dict)

Answer 4

喜欢这样的东西。

base_distribution = {'A' : 0.345, 'C' : 0.158, 'G' : 0.059, 'T' : 0.437}

markov = defaultdict()
for base, val in base_distribution.items():
    markov[base] = markov.get(base, {})
    for key, val in base_distribution.items():
        p = round(base_distribution[base] * base_distribution[key], 4)
        markov[base][key] = markov[base].get(key, p)
pprint(markov)

defaultdict(None,
            {'A': {'A': 0.119, 'C': 0.0545, 'G': 0.0204, 'T': 0.1508},
             'C': {'A': 0.0545, 'C': 0.025, 'G': 0.0093, 'T': 0.069},
             'G': {'A': 0.0204, 'C': 0.0093, 'G': 0.0035, 'T': 0.0258},
             'T': {'A': 0.1508, 'C': 0.069, 'G': 0.0258, 'T': 0.191}})

如何从单个字典创建嵌套字典？

4 个答案: