blocks|key|2530171|text|我想不出一个快速的方法，除了迭代单词的字符，计算字典中每个列表中的出现次数，并在最后对其求和：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2530172|alphabet+=+sorted(set("abbcad"))
rule+=+{'a':+['b',+'d'],+'b':+['b',+'c'],+'c':+['a']}

totalMatrix+=+[]
for+elem+in+alphabet:
++++total+=+0
++++occurences+=+[]
++++for+key+in+rule.keys():
++++++++currentCount+=+rule[key].count(elem)
++++++++total+%2B=+currentCount
++++++++occurences.append((elem,key,currentCount))
++++totalMatrix.append([elem,+total]+%2B+occurences)

for+elem+in+totalMatrix:
++++print(elem)|code-block|syntax|javascript|2530173|totalMatrix的内容为：|offset|length|style|CODE|2530174|['a',+1,+('a',+'a',+0),+('a',+'b',+0),+('a',+'c',+1)]
['b',+2,+('b',+'a',+1),+('b',+'b',+1),+('b',+'c',+0)]
['c',+1,+('c',+'a',+0),+('c',+'b',+1),+('c',+'c',+0)]
['d',+1,+('d',+'a',+1),+('d',+'b',+0),+('d',+'c',+0)]|2530175|entityMap^0|0|0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I cannot think of a quick way other than iterating over the word's characters, counting the occurences in each list of the dictionary and summing it in the end:

<pre><code>alphabet = sorted(set("abbcad"))
rule = {'a': ['b', 'd'], 'b': ['b', 'c'], 'c': ['a']}

totalMatrix = []
for elem in alphabet:
 total = 0
 occurences = []
 for key in rule.keys():
 currentCount = rule[key].count(elem)
 total += currentCount
 occurences.append((elem,key,currentCount))
 totalMatrix.append([elem, total] + occurences)

for elem in totalMatrix:
 print(elem)
</code></pre>

The content of <code>totalMatrix</code> will be:

<pre><code>['a', 1, ('a', 'a', 0), ('a', 'b', 0), ('a', 'c', 1)]
['b', 2, ('b', 'a', 1), ('b', 'b', 1), ('b', 'c', 0)]
['c', 1, ('c', 'a', 0), ('c', 'b', 1), ('c', 'c', 0)]
['d', 1, ('d', 'a', 1), ('d', 'b', 0), ('d', 'c', 0)]
</code></pre>

blocks|key|2318671|text|我只讨论“一个值在字典中出现的频率”，因为您已经说过“一个值在字典中出现的总频率”很容易推断出来。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2318672|如果您只希望能够查找给定键的值的相对频率，那么使用Counter对象的dict很容易实现：|offset|length|style|CODE|2318673|from+collections+import+Counter

rule+=+{'a':+['b',+'d'],+'b':+['b',+'c'],+'c':+['a']}

freq+=+{k:+Counter(v)+for+k,+v+in+rule.items()}|code-block|syntax|javascript|2318674|…它会给你一个类似这样的freq：|2318675|{
++++'a':+Counter({'b':+1,+'d':+1}),
++++'b':+Counter({'b':+1,+'c':+1}),
++++'c':+Counter({'a':+1})
}|2318676|…这样，在给定关键'c'的情况下，您可以获得'a'的相对频率：|2318677|>>>+freq['c']['a']
1|2318678|因为对于不存在的键，Counter对象返回0，所以您也会像预期的那样获得零频率：|2318679|>>>+freq['a']['c']
0|2318680|如果你需要问题中指定的3元组列表，你可以通过一些额外的工作来获得它。这里有一个函数可以做到这一点：|2318681|def+triples(rule):+++++++++++++++
++++freq+=+{k:+Counter(v)+for+k,+v+in+rule.items()}
++++all_values+=+sorted(set().union(*rule.values()))++++++
++++sorted_keys+=+sorted(rule)
++++return+[(v,+k,+freq[k][v])+for+v+in+all_values+for+k+in+sorted_keys]+|2318682|我认为这里唯一不是不言自明的是all_values+=+...行，它：|2318683|使用|2318684|中列表的所有单个元素(注意，使用operator)|unordered-list-item|2318685|
|2318686|converts+|2318687|operator)|ordered-list-item|2318688|converts|2318689|2318690|2318691|+of+a+sorted()+list)，将该集合的列表创建为一个空列表。|2318692|2318693|2318694|2318695|2318696|如果你仍然保留原文，你可以通过使用all_values+=+sorted(set(original_text))来避免所有这些工作。|2318697|这就是它的实际作用：|2318698|>>>+triples({'a':+['b',+'d'],+'b':+['b',+'c'],+'c':+['a']})
[
++++('a',+'a',+0),+('a',+'b',+0),+('a',+'c',+1),
++++('b',+'a',+1),+('b',+'b',+1),+('b',+'c',+0),
++++('c',+'a',+0),+('c',+'b',+1),+('c',+'c',+0),
++++('d',+'a',+1),+('d',+'b',+0),+('d',+'c',+0)
]|2318699|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/collections.html?highlight=counter#collections.Counter|1|https://docs.python.org/3/library/functions.html#sorted^0|0|P|7|Z|4|P|7|0|0|0|C|4|0|0|9|3|M|3|0|0|A|7|0|0|0|0|F|G|0|0|0|0|0|0|1|1|2|6|8|6|8|1|2|1|0|0|0|H|13|0|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|27|8|@$D|28|E|29|F|G]|$D|2A|E|2B|F|G]]|9|@$D|2C|E|2D|1|2E]]|A|$]]|$1|H|3|I|5|J|7|2F|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|2G|8|@$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|2J|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|2K|8|@$D|2L|E|2M|F|G]|$D|2N|E|2O|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|2P|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|2Q|8|@$D|2R|E|2S|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|2T|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|2U|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|2V|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|2W|8|@$D|2X|E|2Y|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|16|3|17|5|18|7|30|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|31|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|18|7|32|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|1F|7|33|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|1F|7|34|8|@]|9|@]|A|$]]|$1|1I|3|1E|5|1F|7|35|8|@]|9|@]|A|$]]|$1|1J|3|1H|5|1F|7|36|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|1F|7|37|8|@$D|38|E|39|F|G]]|9|@$D|3A|E|3B|1|3C]]|A|$]]|$1|1M|3|-4|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|3E|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|3F|8|@]|9|@]|A|$]]|$1|1P|3|-4|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|3H|8|@$D|3I|E|3J|F|G]]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|3K|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|J|7|3L|8|@]|9|@]|A|$K|L]]|$1|1W|3|-4|5|6|7|3M|8|@]|9|@]|A|$]]]|1X|$1Y|$5|1Z|20|21|A|$22|23]]|24|$5|1Z|20|21|A|$22|25]]]]

I'll just deal with "How often a value appears given a key in the dictionary", since you've said that "How often a value appears in the dictionary in total" is easily inferred.

If you just want to be able to look up the relative frequency of a value for a given key, it's easy to get that with a <code>dict</code> of <a href="https://docs.python.org/3/library/collections.html?highlight=counter#collections.Counter" rel="nofollow noreferrer"><code>Counter</code></a> objects:

<pre><code>from collections import Counter

rule = {'a': ['b', 'd'], 'b': ['b', 'c'], 'c': ['a']}

freq = {k: Counter(v) for k, v in rule.items()}
</code></pre>

… which gives you a <code>freq</code> like this:

<pre><code>{
 'a': Counter({'b': 1, 'd': 1}),
 'b': Counter({'b': 1, 'c': 1}),
 'c': Counter({'a': 1})
}
</code></pre>

… so that you can get the relative frequency of <code>'a'</code> given the key <code>'c'</code> like this:

<pre><code>&gt;&gt;&gt; freq['c']['a']
1
</code></pre>

Because <code>Counter</code> objects return 0 for nonexistent keys, you'll also get zero frequencies as you would expect:

<pre><code>&gt;&gt;&gt; freq['a']['c']
0
</code></pre>

If you need a list of 3-tuples as specified in your question, you can get that with a little extra work. Here's a function to do it:

<pre><code>def triples(rule): 
 freq = {k: Counter(v) for k, v in rule.items()}
 all_values = sorted(set().union(*rule.values())) 
 sorted_keys = sorted(rule)
 return [(v, k, freq[k][v]) for v in all_values for k in sorted_keys] 
</code></pre>

The only thing here which I think may not be self-explanatory is the <code>all_values = ...</code> line, which:

<ol>
<li>creates an empty <a href="https://docs.python.org/3/tutorial/datastructures.html#sets" rel="nofollow noreferrer"><code>set()</code></a></li>
<li>produces the <a href="https://docs.python.org/3/library/stdtypes.html#frozenset.union" rel="nofollow noreferrer"><code>union()</code></a> of that set with all the individual elements of the lists in <code>rule.values()</code> (note the use of the <a href="https://docs.python.org/3/tutorial/controlflow.html?highlight=argument%20unpacking#unpacking-argument-lists" rel="nofollow noreferrer">argument-unpacking</a> <code>*</code> operator)</li>
<li>converts the result into a <a href="https://docs.python.org/3/library/functions.html#sorted" rel="nofollow noreferrer"><code>sorted()</code></a> list.</li>
</ol>

If you still have the original text, you can avoid all that work by using e.g. <code>all_values = sorted(set(original_text))</code> instead.

Here it is in action:

<pre><code>&gt;&gt;&gt; triples({'a': ['b', 'd'], 'b': ['b', 'c'], 'c': ['a']})
[
 ('a', 'a', 0), ('a', 'b', 0), ('a', 'c', 1),
 ('b', 'a', 1), ('b', 'b', 1), ('b', 'c', 0),
 ('c', 'a', 0), ('c', 'b', 1), ('c', 'c', 0),
 ('d', 'a', 1), ('d', 'b', 0), ('d', 'c', 0)
]
</code></pre>

I have made a function <code>make_rule(text, scope=1)</code> that simply goes over a string and generates a dictionary that serves as a rule for a Markovian text-generator (where the scope is the number of linked characters, not words).

<pre><code>&gt;&gt;&gt; rule = make_rule("abbcad", 1)
&gt;&gt;&gt; rule
{'a': ['b', 'd'], 'b': ['b', 'c'], 'c': ['a']}
</code></pre>

I have been tasked with calculating the entropy of this system. In order to do that I think I would need to know:

<ol>
<li>How often a value appears in the dictionary in total, i.e. its total frequency.</li>
<li>How often a value appears given a key in the dictionary, i.e. its relative frequency.</li>
</ol>

Is there a quick way to get both of these numbers for each of the values in the dictionary?

For the above example I would need this output:

<pre><code>'a' total: 1, 'a'|'a': 0, 'a'|'b': 0, 'a'|'c': 1
'b' total: 2, 'b'|'a': 1, 'b'|'b': 1, 'b'|'c': 0
'c' total: 1, 'c'|'a': 0, 'c'|'b': 1, 'c'|'c': 0
'd' total: 1, 'd'|'a': 1, 'a'|'b': 1, 'a'|'c': 1
</code></pre>

I guess the <code>'a'</code> total is easily inferred, so maybe instead just output a list of triples for every unique item that appears in the dictionary:

<pre><code>[[('a', 'a', 0), ('a', 'b', 0), ('a', 'c', 1)], [('b', 'a', 1), ('b', 'b', 1), ('b', 'c', 0)], ...]
</code></pre>

Calculating total and relative frequency of values in a dict representing a Markov-chain rule

我制作了一个函数make_rule(text, scope=1)，它简单地遍历一个字符串并生成一个字典，作为马尔可夫文本生成器的规则(其作用域是链接字符的数量，而不是单词)。>>> rule = make_rule("abbcad", 1)>>> rule{'a': ['b', 'd'], 'b': ['b', 'c'...

问计算表示马尔可夫链规则的字典中值的总频率和相对频率
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算表示马尔可夫链规则的字典中值的总频率和相对频率EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算表示马尔可夫链规则的字典中值的总频率和相对频率
EN