Contare le occorrenze numeriche di un carattere in una stringa

Qual è il modo più semplice per contare il numero di occorrenze di un personaggio in una stringa?

ad es. contare il numero di volte in cui 'a'appare'Mary had a little lamb'

str.count (sub [, start [, end]])

Restituisce il numero di occorrenze non sovrapposte della sottostringa subnell'intervallo [start, end]. Gli argomenti opzionali starte endvengono interpretati come in notazione di sezione.

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

Puoi usare count () :

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

Come hanno detto altre risposte, usare il metodo stringa count () è probabilmente il più semplice, ma se lo fai frequentemente, controlla le raccolte .

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

Espressioni regolari forse?

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

myString.count('a');

maggiori informazioni qui

Python-3.x:

"aabc".count("a")

str.count (sub [, start [, end]])

Restituisce il numero di occorrenze non sovrapposte della sottostringa sottotitolo nell'intervallo [inizio, fine]. Gli argomenti opzionali inizio e fine vengono interpretati come nella notazione di sezione.

str.count(a)è la soluzione migliore per contare un singolo carattere in una stringa. Ma se hai bisogno di contare più caratteri dovresti leggere l'intera stringa tante volte quanti sono i caratteri che vuoi contare.

Un approccio migliore per questo lavoro sarebbe:

from collections import defaultdict

text = 'Mary had a little lamb'
chars = defaultdict(int)

for char in text:
    chars[char] += 1

Quindi avrai un dict che restituisce il numero di occorrenze di ogni lettera nella stringa e 0se non è presente.

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

Per un contatore senza distinzione tra maiuscole e minuscole è possibile ignorare i metodi mutatore e accessor mediante la sottoclasse defaultdict(quelli della classe base sono di sola lettura):

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

Questa funzione semplice e diretta potrebbe aiutare:

def check_freq(x):
    freq = {}
    for c in x:
       freq[c] = str.count(c)
    return freq

check_freq("abbabcbdbabdbdbabababcbcbab")
{'a': 7, 'b': 14, 'c': 3, 'd': 3}

Le espressioni regolari sono molto utili se si desidera la distinzione tra maiuscole e minuscole (e naturalmente tutto il potere di regex).

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))

Tieni presente che la versione di regex richiede un tempo di esecuzione dieci volte superiore, il che probabilmente sarà un problema solo se my_string è tremendamente lungo o se il codice è all'interno di un deep loop.

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))

Un modo alternativo per ottenere tutti i conteggi dei personaggi senza usare Counter(), counte 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)

countè sicuramente il modo più conciso ed efficiente di contare l'occorrenza di un personaggio in una stringa ma ho provato a trovare una soluzione usando lambdaqualcosa del genere:

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

Ciò comporterà:

4

Inoltre, c'è un ulteriore vantaggio in questo se la frase è un elenco di sottostringhe che contengono gli stessi caratteri di cui sopra, quindi anche questo dà il risultato corretto a causa dell'uso di in. Dare un'occhiata :

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

Ciò comporta anche:

4

Ma ovviamente questo funzionerà solo quando si verifica la presenza di un singolo carattere, come 'a'in questo caso particolare.

Metodo "Senza usare count per trovare il carattere desiderato nella stringa".

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()

Sono un fan della biblioteca dei panda, in particolare del value_counts()metodo. Puoi usarlo per contare l'occorrenza di ciascun carattere nella tua stringa:

>>> import pandas as pd
>>> phrase = "I love the pandas library and its `value_counts()` method"
>>> pd.Series(list(phrase)).value_counts()
     8
a    5
e    4
t    4
o    3
n    3
s    3
d    3
l    3
u    2
i    2
r    2
v    2
`    2
h    2
p    1
b    1
I    1
m    1
(    1
y    1
_    1
)    1
c    1
dtype: int64

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))

Python 3

Ci sono due modi per raggiungere questo obiettivo:

1) Con conteggio funzioni integrato ()

sentence = 'Mary had a little lamb'
print(sentence.count('a'))`

2) Senza usare una funzione

sentence = 'Mary had a little lamb'    
count = 0

for i in sentence:
    if i == "a":
        count = count + 1

print(count)

Non più di questo IMHO: puoi aggiungere i metodi superiore o inferiore

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