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


954

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'

Réponses:


1332

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


112

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

15
Pourquoi est-ce mieux quand il est utilisé fréquemment? Quel est l'avantage?
meshy

21
Si vous voulez que le nombre de lettres dans une chaîne donnée soit compté, Counter les fournit toutes sous une forme plus succincte. Si vous souhaitez compter une lettre à partir de plusieurs chaînes différentes, Counter n'offre aucun avantage.
Brenden Brown

2
Pour cette instance particulière, en comptant les caractères, je préférerais collections.counter. Pour trouver des instances d'une sous-chaîne spécifique, j'utiliserais une expression régulière ou la méthode str.count (). Je n'ai pas testé, mais il peut y avoir une différence de performances en raison d'une légère surcharge dans le comptage de tous les caractères et l'ajout à un dictionnaire plutôt que de compter les occurrences d'une seule sous-chaîne. Je suggérerais d'écrire un script pour générer un très long fichier à rechercher, puis chronométrer l'exécution de chaque méthode.
Daniel B.

5
L'avantage, lorsqu'il est utilisé fréquemment, est que Counter calcule tous les comptes UNE FOIS, ce qui est presque aussi rapide que de faire mystring.count ('a') une fois. Ainsi, si vous effectuez cette opération 20 fois, vous économisez peut-être 10 fois le temps de calcul. Le compteur peut également vous dire si un élément est dans la chaîne: par exemple, si «a» dans le compteur:
BAMF4bacon

51

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

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

30
Une bonne idée, mais exagérée dans ce cas. La méthode de chaîne 'count' fait la même chose avec le bonus supplémentaire d'être immédiatement évidente sur ce qu'elle fait.
nilamo

18
pourquoi un taux négatif, peut-être que quelqu'un a besoin de ce type de code pour quelque chose de similaire. mon vote
kiltek

12
Cela devrait être rétrogradé car c'est le moyen le moins efficace possible de compter les caractères dans une chaîne. Si le but est simplement de compter les caractères, comme l'indique la question, il serait difficile de trouver une pire façon de faire le travail. En termes de mémoire et de surcharge du processeur, cette solution est définitivement à éviter. Personne n'aura jamais "besoin" d'utiliser cette méthode pour trouver le nombre de caractères dans une chaîne.
Christopher

1
@kiltek En effet, ce petit extrait m'a été utile avec une expression régulière un peu plus complexe
Speccy

bonne solution lorsque les méthodes de chaîne ne sont pas disponibles:len(re.findall('1',bin(10)))
Conor


16

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.


13

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

Vous êtes en train de réimplémenter Counter, qui est déjà une classe collections.
merv

@merv Pas vraiment. Counterest une classe Python pur plus pléthorique et defaultdictl » __missing__est écrit en C . Pour une tâche simple comme celle-ci ( intest également implémentée en C), cette approche est légèrement plus rapide.
Nuno André

11

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}

3
Vous observez str. Si vous donnez son nom à la variable, ce strn'est plus un type intégré. Vous comptez également quatorze fois quatorze b. Vous pouvez éviter cela simplement en changeant for c in textavec for c in set(text).
Nuno André

10

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.


1
Regex est exagéré si vous essayez simplement de corriger la sensibilité à la casse. my_sting.lower (). count ('m') est plus performant, plus clair et plus succinct.
Codes Ogre

5
a = 'have a nice day'
symbol = 'abcdefghijklmnopqrstuvwxyz'
for key in symbol:
    print key, a.count(key)

2
str = "count a character occurance"

List = list(str)
print (List)
Uniq = set(List)
print (Uniq)

for key in Uniq:
    print (key, str.count(key))

2

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)

1

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.


0

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

7
Pourquoi la fonction de comptage vide? Pourquoi la fonction main ()? Pourquoi les espaces laids partout? Ce n'est PAS une bonne réponse.
bugmenot123

0

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

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

-1

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)

-2

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)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.