Réponses:
str.count (sub [, start [, end]])
Renvoie le nombre d'occurrences non superposées de sous-chaîne
sub
dans la plage[start, end]
. Les arguments facultatifsstart
etend
sont interprétés comme en notation de tranche.
>>> sentence = 'Mary had a little lamb'
>>> sentence.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))
len(re.findall('1',bin(10)))
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 0
si 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
Counter
, qui est déjà une classe collections
.
Counter
est une classe Python pur plus pléthorique et defaultdict
l » __missing__
est écrit en C . Pour une tâche simple comme celle-ci ( int
est également implémentée en C), cette approche est légèrement plus rapide.
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}
str
. Si vous donnez son nom à la variable, ce str
n'est plus un type intégré. Vous comptez également quatorze fois quatorze b. Vous pouvez éviter cela simplement en changeant for c in text
avec for c in set(text)
.
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.
Une façon alternative d'obtenir tous les décomptes de caractères sans utiliser Counter()
, count
et 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
est 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 lambda
quelque 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
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)