Question

任何人都可以帮我使用Python代码返回给定字符串中最常出现的字符及其各自的计数吗？

例如，"aaaaabbbbccc", 2应返回[('a', 5), ('b', 4)]

如果出现平局，后面会出现字母字符在订购中。例如：

 "cdbba",2 -> [('b',2), ('d',1)]
 'cdbba',3 -> [('b',2), ('d',1), ('c',1)]

Answer 1

这可能是你的开始：

 from collections import Counter
 import string
 s = "aaaaabbbbccc"
 counter = Counter(s)

 for c in string.ascii_letters:
     if counter[c] > 0:
          print (c, counter[c])

您可以调整代码，而不是打印，将结果保存在列表中，对其进行排序并打印前2个结果

Answer 2

首先 - 到目前为止你尝试了什么？ 请在询问之前阅读this！

要解决这个问题，首先要创建一个频率字典，然后将其转换为元组数组，最后排序。

def freq(st, n):
    # Create the dictionary
    dct = {}
    for c in st:
        dct[c] = dct.get(c, 0) + 1
    # Convert to array of tuples
    ar = [(key, val) for key, val in dct.iteritems()]
    # Sort the array:
    ar.sort(key=lambda x: x[1])

    return ar[:n]

这不会完全解决你的问题 - 你仍然需要弄清楚如何打破关系。这是一种方法：创建另一个第一次出现的字典（只是一个以字符为键，索引为值的字典），然后在识别关系时再次检查迭代并解析它们。

Answer 3

def freq(word, n):
    l1 = list(word)
    l3 = []
    l2 = []
    l4 = []
    s = set(l1)
    l2 = list(s)

    def count(p):
        c = 0
        for a in word:
            if a in word:
                c = c + p.count(a)
        l3.append(c)
        return c

    l2.sort(key=count)

    l3.sort()
    l4 = list(zip(l2, l3))
    l4.reverse()
    l4.sort(key=lambda l4: ((l4[1]), (l4[0])), reverse=True)
    return l4[0:n]
    pass

Answer 4

def freq（word，n）： RES = [] a = [] b = [] C = 0

if type(word) != str or type(n) != int:
    c = 1
    raise TypeError
if n <= 0:
    c = 1
    raise ValueError
for x in word:
    a.append(x)
    b.append(word.count(x))
c = zip(a, b)
c = list(set(c))
c.sort(key=lambda t: t[0], reverse=True)

c.sort(key=lambda t: t[1], reverse=True)
count=0
for x in range(len(c)):
    count+=1
if n>count:
    n=count
for x in range(n):
    res.append(c[x],)
return res

Answer 5

Counter内置类提供了一个名为most_common的函数。

从中返回n个最常见元素及其计数的列表最常见的。如果省略n或None，则most_common（）返回计数器中的所有元素。具有相同计数的元素是任意订购：

获取字符及其频率后，我们需要先对其频率进行排序，如果存在平局，我们选择ascii代码最高的字符。然后，我们只选取N个最常用的元素切片。

from collections import Counter

s = "cdbba"
sorted_counter = sorted(Counter(s).most_common(), 
                        key = lambda x: (-x[1], -ord(x[0])))
slice_counter = sorted_counter[:2] # here you select n most common
>[('b',2), ('d',1)]
slice_counter = sorted_counter[:3] # here you select n most common
>[('b',2), ('d',1), ('c',1)]

给定字符串中所需字符的频率

5 个答案: