在Python中计算字符串中的重复字符

我想计算字符串中每个字符的重复次数。除了比较A-Z中字符串的每个字符外，还有什么特殊的方法可以做到这一点吗 增加一个计数器

更新（参考）：到目前为止，无论你提出什么建议，我都要写26次。有更简单的方法吗？

您想使用一个

collections.defaultdict

类似于

dict

（实际上是它的子类），但是当一个条目被查找但没有找到时，它会通过调用提供的0参数callable来创建并插入它，而不是报告它没有条目。最流行的是用于计数的

defaultdict（int）

（或者，等价地，用于生成一个多集数据结构）和

defaultdict（list）

，它永远不需要使用

.setdefault（akey，[]）.append（avalue）

和类似的笨拙习惯用法

因此，一旦你完成了这个

d

就是一个类似dict的容器，它将每个字符映射到它出现的次数，当然，你可以以任何你喜欢的方式发出它。例如，最受欢迎的角色优先：

for c in sorted(d, key=d.get, reverse=True):
  print '%s %6d' % (c, d[c])

---

您可以使用字典：

s = "asldaksldkalskdla"
dict = {}
for letter in s:
 if letter not in dict.keys():
  dict[letter] = 1
 else:
  dict[letter] += 1

print dict

---

我的第一个想法是这样做：

chars = "abcdefghijklmnopqrstuvwxyz"
check_string = "i am checking this string to see how many times each character appears"

for char in chars:
  count = check_string.count(char)
  if count > 1:
    print char, count

然而，这不是一个好主意！这将扫描字符串26次，因此您可能要比其他一些答案多做26倍的工作。你真的应该这样做：

count = {}
for s in check_string:
  if s in count:
    count[s] += 1
  else:
    count[s] = 1

for key in count:
  if count[key] > 1:
    print key, count[key]

这样可以确保只遍历字符串一次，而不是26次

---

另外，Alex的回答很好-我不熟悉collections模块。我以后会用的。他的回答比我的更简洁，技术上也更优越。我建议使用他的代码而不是我的。

这是我能想到的最短、最实用的代码，无需导入额外的模块

text = "hello cruel world. This is a sample text"
d = dict.fromkeys(text, 0)
for c in text: d[c] += 1

打印d['a']将输出2

---

而且速度也很快。

我能用双手数出我认识Python的天数，所以如果我回答了一些愚蠢的问题，请原谅：）

我想，为什么不用一张单子来代替口述呢？我不确定列表和字典是如何在Python中实现的，因此必须对其进行度量才能知道什么更快

如果这是C++，我只会使用一个普通的C数组/向量来进行常量访问（这肯定会更快），但是我不知道Python中的相应数据类型（如果有一个……）：

也可以将列表的大小设为ord（'z'），然后在所有地方消除97减法，但是如果您进行了优化，为什么不一路优化呢：）

编辑： 一位评论员建议，使用列表可能带来的好处不值得加入/拆分，因此我想为什么不放弃它：

count = [0 for i in range(26)]

for c in s:
    if c.isalpha(): count[ord(c.lower()) - 97] += 1

Python 2.7+包括以下类：

这是解决办法

my_list=[]
history=""
history_count=0
my_str="happppyyyy"


for letter in my_str:
    if letter in history:
        my_list.remove((history,history_count))
        history=letter
        history_count+=1

    else:
        history_count=0
        history_count+=1
        history=letter


my_list.append((history,history_count))    


print my_list

---

如果有人正在寻找没有

集合

模块的最简单方法。我想这会有帮助：

>>> s = "asldaksldkalskdla"
>>> {i:s.count(i) for i in set(s)}
{'a': 4, 'd': 3, 'k': 3, 's': 3, 'l': 4}

或

如果我的字符串是：

str = "this is string!"

上述代码将打印：

{'!': 1, ' ': 2, 'g': 1, 'i': 3, 'h': 1, 'n': 1, 's': 3, 'r': 1, 't': 2}

---

这将显示具有出现计数的字符的dict

str = 'aabcdefghijklmnopqrstuvwxyz'
mydict = {}
for char in str:
    mydict[char]=mydict.get(char,0)+1
 print mydict

大型性能比较 滚动至末尾以获得TL；DR图形

因为我“没有更好的事要做”（明白：我只有很多工作），我决定去做 一场小小的表演比赛。我收集了最明智或最有趣的答案，然后做了 一些简单的

timeit

，在CPython 3.5.1中。我只用一个字符串测试了它们 是我案例中的典型输入：

>>> s = 'ZDXMZKMXFDKXZFKZ'
>>> len(s)
16

请注意，对于不同的输入，结果可能会有所不同，可能是字符串的长度不同，也可能是不同的 不同的不同字符数，或每个字符的平均出现次数不同

---

轮子 Python让我们变得简单了。

collections.Counter

类正是我们想要的 还有更多。它的用法是这里提到的所有方法中最简单的

取自@oefe，很好的发现

计数器

要多走一英里，这就是为什么要花这么长时间

字典？ 让我们试着使用一个简单的

dict

。首先，让我们使用dict以声明的方式进行 理解力

这是我自己想出来的

这将从头到尾通过

s

，并对每个字符计数 它在

s

中出现的次数。由于

s

包含重复的字符，因此上述方法将进行搜索

s

对同一字符执行多次。结果自然总是一样的。让我们数一数 每个字符仅出现一次的次数

这是我自己想出来的，IrshadBhat也是

更好。但是我们仍然需要搜索字符串来计算发生的次数。一次搜索 每个不同的字符。这意味着我们要多次读取字符串。我们能做到 比那更好！但要做到这一点，我们必须放下我们的宣示主义者的架子，走下正轨 必须的心态

例外代码 我一定要抓住他们

灵感来源于安东尼

嗯，值得一试。如果您深入研究Python源代码（我不能肯定地说，因为 我从来没有这样做过），您可能会发现，当您执行除ExceptionType之外的

时，
Python必须检查引发的异常实际上是
ExceptionType
还是其他类型的异常
类型。只是为了见鬼，让我们看看如果我们忽略了检查和捕获需要多长时间
所有例外

由安东尼制作

它确实节省了一些时间，因此人们可能会尝试将其用作某种优化

不要那样做或实际上是这样。现在就做：

插曲1

看到了吗？除其他功能外，它还捕获键盘中断。事实上，它抓住了所有的机会
但也有例外。包括您可能从未听说过的，如
SystemExit

INTE
>>> [(i,s.count(i)) for i in set(s)]
[('a', 4), ('k', 3), ('s', 3), ('l', 4), ('d', 3)]

dict = {}
for i in set(str):
    b = str.count(i, 0, len(str))
    dict[i] = b
print dict

str = "this is string!"

{'!': 1, ' ': 2, 'g': 1, 'i': 3, 'h': 1, 'n': 1, 's': 3, 'r': 1, 't': 2}

str = 'aabcdefghijklmnopqrstuvwxyz'
mydict = {}
for char in str:
    mydict[char]=mydict.get(char,0)+1
 print mydict

>>> s = 'ZDXMZKMXFDKXZFKZ'
>>> len(s)
16

>>> timeit('Counter(s)', globals=locals())
8.208566107001388

>>> timeit('{c: s.count(c) for c in s}', globals=locals())
4.551155784000002

>>> timeit('{c: s.count(c) for c in set(s)}', globals=locals())
3.1484066140001232

>>> timeit('''
... d = {}
... for c in s:
...   try:
...     d[c] += 1
...   except KeyError:
...     d[c] = 1
... ''', globals=locals())
3.7060273620008957

>>> timeit('''
... d = {}
... for c in s:
...   try:
...     d[c] += 1
...   except:
...     d[c] = 1
... ''', globals=locals())
3.3506563019982423

import time
while True:
  try:
    time.sleep(1)
  except:
    print("You're trapped in your own trap!")

import sys
try:
  print("Goodbye. I'm going to die soon.")
  sys.exit()
except:
  print('BACK FROM THE DEAD!!!')

>>> timeit('''
... d = {}
... for c in s:
...   d[c] = d.get(c, 0) + 1
... ''', globals=locals())
3.2133633289995487

>>> timeit('''
... dd = defaultdict(int)
... for c in s:
...   dd[c] += 1
... ''', globals=locals())
3.3430528169992613

>>> timeit('''
... d = dict.fromkeys(s, 0)
... for c in s:
...   d[c] += 1
... ''', globals=locals())
2.6081761489986093

d.update({ c: 0 for c in set(other_string) - d.keys() })

>>> timeit('''
... counts = [0 for _ in range(256)]
... for c in s:
...   counts[ord(c)] += 1
... d = {chr(i): count for i,count in enumerate(counts) if count != 0}
... ''', globals=locals())
25.438595562001865

>>> timeit('''
... counts = [0 for _ in range(256)]
... for c in s:
...   counts[ord(c)] += 1
... ''', globals=locals())
10.564866792999965

>>> timeit('''
... counts = [0] * 256
... for c in s:
...   counts[ord(c)] += 1
... ''', globals=locals())
3.290163638001104

>>> timeit('''
... counts = [0] * 256
... for c in s:
...   counts[ord(c)] += 1
... d = {chr(i): count for i,count in enumerate(counts) if count != 0}
... ''', globals=locals())
18.000623562998953

>>> timeit('''
... counts = [0] * 256
... for c in s:
...   counts[ord(c)] += 1
... d = {c: counts[ord(c)] for c in set(s)}
... ''', globals=locals())
5.826531438000529

>>> timeit('''
... d = {}
... for c in s:
...   if c in d:
...     d[c] += 1
...   else:
...     d[c] = 1
... ''', globals=locals())
1.8509794599995075

Help on built-in function _count_elements in module _collections:

_count_elements(...)
    _count_elements(mapping, iterable) -> None

    Count elements in the iterable, updating the mappping
>>> timeit('''
... d = {}
... _count_elements(d, s)
... ''', globals=locals())
1.229239897998923

def count_repeated_letter(string1):
    list1=[]

    for letter in string1:
        if string1.count(letter)>=2:
            if letter not in list1:
                list1.append(letter)


    for item in list1:
        if item!= " ":
            print(item,string1.count(item))


count_repeated_letter('letter has 1 e and 2 e and 1 t and two t')

e 4
t 5
a 4
1 2
n 3
d 3

variable = 'turkiye'
print(variable.count('u'))

word = "babulibobablingo"
letter = 'b'

if letter in word:
    print(word.count(letter))

inputString =  input("Enter a String:")
countedArray = {}

for char in inputString:
    if char in countedArray:  
        countedArray[char] += 1    
    else:
        countedArray[char] = 1
    
print(countedArray) 

s = 'today is sunday i would like to relax'
numberOfDuplicatedChar = len(s) - len(set(s))