Подсчет количества вхождений символа в строку

Да, регулярные выражения — это подходящее решение для данной задачи. В приведённом коде используется модуль re для поиска всех вхождений буквы "a" в строке my_string.

Код работает следующим образом:

1. Импортируется модуль re.
2. Определяется строка my_string, содержащая текст "Mary had a little lamb".
3. С помощью функции re.findall ищутся все вхождения символа "a" в строке. Эта функция возвращает список всех найденных совпадений.
4. Функция len вычисляет длину этого списка, что соответствует количеству вхождений буквы "a".

В итоге, код возвращает количество раз, которое буква "a" встречается в строке. Если вам нужно просто посчитать количество вхождений определённого символа или подстроки, регулярные выражения — удобный инструмент для этой задачи.

Вот ваш код:

import re
my_string = "Mary had a little lamb"
count_a = len(re.findall("a", my_string))
print(count_a)  # Вывод: 3

В данном случае результатом будет 3, поскольку буква "a" появляется трижды в строке.

Вот простая и понятная функция, которая может помочь вам:

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

print(check_freq("abbabcbdbabdbdbabababcbcbab"))
# Вывод: {'a': 7, 'b': 14, 'c': 3, 'd': 3}

Если вам удобнее использовать генератор словарей, вот альтернативный вариант:

def check_freq(x):
    return {c: x.count(c) for c in set(x)}

Оба варианта возвращают словарь, где ключи — это уникальные символы строки, а значения — количество их вхождений. Вы можете выбрать тот вариант, который больше подходит вашему стилю кодирования.

str.count(a) — это наилучшее решение для подсчёта вхождений одного символа в строку. Однако если вам нужно подсчитать несколько символов, вам придётся прочитать всю строку столько раз, сколько символов вы хотите посчитать.

Лучше подойти к этой задаче следующим образом:

from collections import defaultdict

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

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

Таким образом, у вас будет словарь, который возвращает количество вхождений каждой буквы в строке и 0, если символ не присутствует.

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

Для нечувствительного к регистру счётчика вы можете переопределить методы доступа и изменения значений, создав подкласс defaultdict (методы базового класса являются только для чтения):

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

Если вы хотите подсчитать количество вхождений буквы 'a' в заданном предложении, вы можете использовать метод count() для строк в Python. Вот пример:

sentence = 'A man walked up to a door'
print(sentence.count('a'))
# 4

В данном случае метод count() возвращает количество появлений символа 'a' в строке sentence. Обратите внимание, что он учитывает регистр, поэтому буква 'A' (заглавная) и 'a' (строчная) будут считаться отдельно. Если вам нужно учесть регистронезависимое сравнение, вы можете преобразовать строку в нижний регистр перед подсчетом:

print(sentence.lower().count('a'))
# 5

Это даст вам общее количество 'a', независимо от регистра.

Регулярные выражения очень полезны, если вам нужна нечувствительность к регистру (и, конечно, все возможности regex).

Вот пример кода:

my_string = "Mary had a little lamb"
# самый простой способ, использующий count, чувствителен к регистру
my_string.count("m")   # результат 1
import re
# чувствительность к регистру с помощью regex
len(re.findall("m", my_string))
# три способа получить нечувствительность к регистру - все дают 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))

Учтите, что версия с регулярными выражениями будет выполняться примерно в десять раз дольше, что, вероятно, станет проблемой только в случае, если my_string будет очень длинной или если код окажется внутри глубокого цикла.