Cuente el número de apariciones de un carácter en una cadena

¿Cuál es la forma más sencilla de contar el número de apariciones de un carácter en una cadena?

por ejemplo, cuente el número de veces que aparece 'a' en 'Mary had a little lamb'

str.count (sub [, inicio [, final]])

Devuelve el número de apariciones no superpuestas de subcadena sub en el rango [start, end] . Los argumentos opcionales de start y end se interpretan como en notación de segmento.

 >>> sentence = 'Mary had a little lamb' >>> sentence.count('a') 4 

Puedes usar count () :

 >>> 'Mary had a little lamb'.count('a') 4 

Como dijeron otras respuestas, usar el método de cadena count () es probablemente el más simple, pero si lo hace con frecuencia, eche un vistazo a las colecciones .

 from collections import Counter my_str = "Mary had a little lamb" counter = Counter(my_str) print counter['a'] 

Expresiones regulares tal vez?

 import re my_string = "Mary had a little lamb" len(re.findall("a", my_string)) 
 myString.count('a'); 

más información aquí

 "aabc".count("a") 

str.count(a) es la mejor solución para contar un solo carácter en una cadena. Pero si necesita contar más caracteres, tendría que leer toda la cadena tantas veces como caracteres quiera contar.

Un mejor enfoque para este trabajo sería:

 from collections import defaultdict text = 'Mary had a little lamb' chars = defaultdict(int) for char in text: chars[char] += 1 

Así que tendrás un dict que devuelve el número de apariciones de cada letra en la cadena y 0 si no está presente.

 >>>chars['a'] 4 >>>chars['x'] 0 

Para un contador que no distingue entre mayúsculas y minúsculas, puede anular los métodos mutador y de acceso mediante la subclase defaultdict (los de clase base son de solo lectura)

 class CICounter(defaultdict): def __getitem__(self, k): return super().__getitem__(k.lower()) def __setitem__(self, k, v): super().__setitem__(k.lower(), v) chars = CICounter(int) for char in text: chars[char] += 1 >>>chars['a'] 4 >>>chars['M'] 2 >>>chars['x'] 0 

Las expresiones regulares son muy útiles si desea insensibilidad a las mayúsculas y minúsculas (y, por supuesto, todo el poder de las expresiones regulares).

 my_string = "Mary had a little lamb" # simplest solution, using count, is case-sensitive my_string.count("m") # yields 1 import re # case-sensitive with regex len(re.findall("m", my_string)) # three ways to get case insensitivity - all yield 2 len(re.findall("(?i)m", my_string)) len(re.findall("m|M", my_string)) len(re.findall(re.compile("m",re.IGNORECASE), my_string)) 

Tenga en cuenta que la versión de expresiones regulares lleva aproximadamente diez veces más tiempo de ejecución, lo que probablemente será un problema solo si my_string es tremendamente largo, o si el código está dentro de un bucle profundo.

Esta función fácil y directa podría ayudar:

 def check_freq(str): freq = {} for c in str: freq[c] = str.count(c) return freq check_freq("abbabcbdbabdbdbabababcbcbab") {'a': 7, 'b': 14, 'c': 3, 'd': 3} 
 a = 'have a nice day' symbol = 'abcdefghijklmnopqrstuvwxyz' for key in symbol: print key, a.count(key) 
 str = "count a character occurance" List = list(str) print (List) Uniq = set(List) print (Uniq) for key in Uniq: print (key, str.count(key)) 

count es definitivamente la forma más concisa y eficiente de contar la aparición de un personaje en una cadena, pero traté de encontrar una solución utilizando lambda , algo como esto:

 sentence = 'Mary had a little lamb' sum(map(lambda x : 1 if 'a' in x else 0, sentence)) 

Esto resultará en:

 4 

Además, hay una ventaja más de esto es que si la oración es una lista de sub-cadenas que contienen los mismos caracteres que arriba, entonces esto también da el resultado correcto debido al uso de in . Echar un vistazo :

 sentence = ['M', 'ar', 'y', 'had', 'a', 'little', 'l', 'am', 'b'] sum(map(lambda x : 1 if 'a' in x else 0, sentence)) 

Esto también resulta en:

 4 

Pero, por supuesto, esto funcionará solo cuando se verifique la ocurrencia de un solo carácter como 'a' en este caso particular.

“Sin usar el conteo para encontrar que quieres el carácter en cadena” método.

 import re def count(s, ch): pass def main(): s = raw_input ("Enter strings what you like, for example, 'welcome': ") ch = raw_input ("Enter you want count characters, but best result to find one character: " ) print ( len (re.findall ( ch, s ) ) ) main() 
 spam = 'have a nice day' var = 'd' def count(spam, var): found = 0 for key in spam: if key == var: found += 1 return found count(spam, var) print 'count %s is: %s ' %(var, count(spam, var)) 

No más que este IMHO: puede agregar los métodos superior o inferior

 def count_letter_in_str(string,letter): return string.count(letter) 

Usando Count:

 string = "count the number of counts in string to count from." x = string.count("count") 

x = 3.

Una forma alternativa de obtener todos los conteos de caracteres sin usar Counter() , count y regex

 counts_dict = {} for c in list(sentence): if c not in counts_dict: counts_dict[c] = 0 counts_dict[c] += 1 for key, value in counts_dict.items(): print(key, value) 

Esto le dará la aparición de cada carácter en una cadena. O / P también está en formato de cadena:

 def count_char(string1): string2="" lst=[] lst1=[] for i in string1: count=0 if i not in lst: for j in string1: if i==j: count+=1 lst1.append(i) lst1.append(count) lst.append(i) string2=''.join(str(x) for x in lst1) return string2 print count_char("aabbacddaabbdsrchhdsdg")