Compter le nombre d'occurrences d'un caractère dans une chaîne

Quelle est la façon la plus simple de compter le nombre d'occurrences d'un caractère dans une chaîne?

par exemple compter le nombre de fois 'a'apparaît dans'Mary had a little lamb'

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

Renvoie le nombre d'occurrences non superposées de sous-chaîne subdans la plage [start, end]. Les arguments facultatifs startet endsont interprétés comme en notation de tranche.

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

Vous pouvez utiliser count () :

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

Comme d'autres réponses l'ont dit, l'utilisation de la méthode de la chaîne count () est probablement la plus simple, mais si vous le faites fréquemment, consultez les collections .

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

Des expressions régulières peut-être?

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

myString.count('a');

plus d'infos ici

Python-3.x:

"aabc".count("a")

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

Renvoie le nombre d'occurrences non superposées de sous-chaîne dans la plage [début, fin]. Les arguments facultatifs début et fin sont interprétés comme en notation de tranche.

str.count(a)est la meilleure solution pour compter un seul caractère dans une chaîne. Mais si vous devez compter plus de caractères, vous devrez lire la chaîne entière autant de fois que vous voulez compter.

Une meilleure approche pour ce travail serait:

from collections import defaultdict

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

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

Vous aurez donc un dict qui renvoie le nombre d'occurrences de chaque lettre de la chaîne et 0si elle n'est pas présente.

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

Pour un compteur insensible à la casse, vous pouvez remplacer les méthodes de mutateur et d'accesseur en sous-classant defaultdict(celles de la classe de base sont en lecture seule):

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

Cette fonction simple et directe pourrait aider:

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}

Les expressions régulières sont très utiles si vous voulez une insensibilité à la casse (et bien sûr toute la puissance de l'expression régulière).

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

Sachez que la version regex prend dix fois plus de temps à s'exécuter, ce qui ne sera probablement un problème que si my_string est extrêmement longue ou si le code se trouve dans une boucle profonde.

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

Une façon alternative d'obtenir tous les décomptes de caractères sans utiliser Counter(), countet 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)

countest certainement le moyen le plus concis et le plus efficace de compter l'occurrence d'un caractère dans une chaîne, mais j'ai essayé de trouver une solution en utilisant lambdaquelque chose comme ceci:

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

Cela se traduira par:

4

En outre, il y a un autre avantage à cela: si la phrase est une liste de sous-chaînes contenant les mêmes caractères que ci-dessus, cela donne également le résultat correct en raison de l'utilisation de in. Regarde :

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

Cela se traduit également par:

4

Mais bien sûr, cela ne fonctionnera que lors de la vérification de l'occurrence d'un seul caractère, comme 'a'dans ce cas particulier.

"Sans utiliser count pour trouver le caractère souhaité dans la chaîne".

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

Je suis fan de la bibliothèque pandas, en particulier de la value_counts()méthode. Vous pouvez l'utiliser pour compter l'occurrence de chaque caractère de votre chaîne:

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

Il y a deux façons d'y parvenir:

1) Avec nombre de fonctions intégré ()

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

2) Sans utiliser de fonction

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

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

print(count)

Pas plus que cette IMHO - vous pouvez ajouter les méthodes supérieures ou inférieures

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