count: считаем вхождения в строке

В уроке 14 ты искал подстроку методом find и проверял её наличие через in. Поиск отвечает на вопрос «где?», но в реальных задачах чаще нужно «сколько»: сколько раз покупатель взял молоко, сколько ошибок в журнале, сколько слов в отзыве. За вопрос «сколько?» отвечает метод count — главный герой этого урока.

count: считаем вхождения подстроки

order = 'молоко, хлеб, молоко, сыр, молоко'
print(order.count('молоко'))
print(order.count('хлеб'))
print(order.count('кефир'))

3
1
0

Схема простая: s.count(подстрока) возвращает число — сколько раз подстрока встретилась в строке. Подстроки нет — вернётся 0, и это не ошибка, а нормальный ответ: ноль вхождений значит «не встречалась». Тот же метод работает и на списках: разобрав строку на слова через split из урока 9, можно посчитать частоту слова уже среди слов.

Непересекающиеся вхождения

print('ааа'.count('аа'))
print('аааа'.count('аа'))
print('ааааа'.count('аа'))

1
2
2

s = 'ааа'
n = 0
pos = s.find('аа')
while pos != -1:
    n += 1
    pos = s.find('аа', pos + 1)
print(n)

2

Символы, диапазон и слова

Считать можно и одиночные символы — это самый частый случай. Два необязательных аргумента задают диапазон: s.count('о', 3) ищет только с индекса 3, третий аргумент ограничивает поиск справа. Для подсчёта слов строку сначала разбирают на слова через len(s.split()), а частоту конкретного слова считает count уже по списку слов.

word = 'молоко'
print(word.count('о'))
print(word.count('о', 3))

order = 'молоко молоко хлеб сыр молоко'
words = order.split()
print(len(words))
print(words.count('молоко'))

3
2
5
3

Метод count отвечает на вопрос «сколько?» одной строкой — без циклов и ручных счётчиков. Он не заменяет find из урока 14: find говорит, где подстрока, count — сколько её. А следующий урок покажет, как ровно расставить такие подсчёты по колонкам: ljust, rjust и zfill растянут строки до нужной ширины.

Как посчитать количество вхождений подстроки: count

count отвечает на вопрос «сколько?»: сколько раз товар встретился в заказе, сколько ошибок в журнале, сколько букв «о» в слове. Метод возвращает целое число, ничего не меняет и никогда не падает — если подстроки нет, ответ 0. Это делает его безопасным в условиях: результат можно сразу сравнивать с порогом, не проверяя «а нашлось ли вообще что-нибудь».

order = 'молоко, хлеб, молоко, сыр, молоко'
print(order.count('молоко'))
print(order.count('хлеб'))
print(order.count('кефир'))

3
1
0

Третья строка — важная: отсутствие подстроки даёт 0, а не ошибку. Многие методы строк ведут себя противоположно — например, find возвращает -1, и код, забывший про это, ломается. С count такой ошибки не бывает: ноль вхождений значит «не встречалась», и это законченный ответ.

Непересекающиеся вхождения

Главная особенность count — он считает непересекающиеся вхождения. Поиск идёт слева направо, и после каждого совпадения продолжение начинается за концом найденного куска. Проверим на классике.

print('ааа'.count('аа'))
print('аааа'.count('аа'))
print('ааааа'.count('аа'))

1
2
2

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

s = 'ааа'
n = 0
pos = s.find('аа')
while pos != -1:
    n += 1
    pos = s.find('аа', pos + 1)
print(n)

2

Цикл работает, но писать его каждый раз лень. В реальном коде для подсчёта пересечений используют либо регулярное выражение с lookahead — len(re.findall('(?=(аа))', s)) — либо просто не задачу с пересечениями: в реальных данных «ааа» подряд почти не встречается, а вот «молоко, молоко» — постоянно.

Диапазон поиска: второй и третий аргументы

У count есть два необязательных аргумента, которые сужают область поиска. Второй — с какого индекса начинать, третий — до какого заканчивать. Это не «сколько вхождений искать», а границы диапазона, и путать эти два смысла опасно.

log = '2026-03-14 ERROR диск 2026-03-14 ERROR память'
print(log.count('ERROR'))
print(log.count('ERROR', 10))
print(log.count('ERROR', 10, 30))

2
2
1

Третий вывод — самый полезный: между индексами 10 и 30 помещается только первое слово ERROR, второе начинается за тридцатым символом. Такая разбивка нужна, когда в строке смешаны разные типы записей и нужно посчитать что-то в одном куске, не затрагивая остальное.

Считаем слова: split и count

Подсчёт слов — самая частая задача, и тут count на строке не поможет: он ищет подстроку, а не слово. «молоко» в строке «молоковенный» тоже найдётся. Правильный приём — сначала разбить строку на слова, а потом считать уже среди слов.

word = 'молоко'
print(word.count('о'))
print(word.count('о', 3))

order = 'молоко молоко хлеб сыр молоко'
words = order.split()
print(len(words))
print(words.count('молоко'))

3
2
5
3

Разберём выводы. Первая строка — количество букв «о» в слове. Вторая — сколько из них начиная с третьего символа: в «молоко» буквы «о» стоят на позициях 3 и 5, и третья позиция — это как раз начало «о». Третья — количество слов в заказе: пять. Четвёртая — сколько раз среди слов встречается «молоко»: три. Заметьте, что четвёртая строка считает уже по списку, а не по строке, — и «молоковенный» таким способом посчитано не будет.

И последнее. count не понимает регулярные выражения: ищет он буквальную подстроку. Если нужно посчитать «сколько раз в строке встречается слово, начинающееся с Error», обычный count не поможет — тут нужен re.findall из курса регулярных выражений. Но в 90 процентах задач хватает простого count, и это хорошая новость: метод работает на C и не создаёт копий строки.

Считаем в логах и CSV: где count незаменим

Отдельный сюжет — подсчёт по журналу. Типичная задача: посчитать, сколько раз за ночь появилась ошибка определённого вида, и проверить, не превысила ли частота порог. Здесь count работает идеально, потому что нужен именно счётчик совпадений, а не список найденных мест.

log = '2026-03-14 ERROR диск 2026-03-14 ERROR память'
errors = log.count('ERROR')
print('Ошибок за ночь:', errors)
if errors > 1:
    print('Нужно разбираться')

Ошибок за ночь: 2
Нужно разбираться

Здесь count даёт то, ради чего его и используют: одно число вместо цикла со счётчиком. Код читается как условие, а не как алгоритм. Если бы совпадений было много и нужны были бы их позиции, count уже не подойдёт — тогда цикл с find, как мы разбирали в начале урока.

Для CSV то же самое с оговоркой: count по строке найдёт искомое и внутри других значений. Если файл устроен как «значение1;значение2;...» и нужно посчитать вхождения именно в первом поле, придётся разбирать построчно. Тот самый скелет из финального проекта: чистка, разбор, подсчёт.

И напоследок о скорости. count реализован на уровне C и работает за один проход по строке — на тексте в десятки мегабайт он отработает быстрее, чем Python-цикл с find в сто раз. Для логов, которые пишутся постоянно, эта разница превращается в разницу между «успеваем обрабатывать поток» и «не успеваем».

Частые ошибки при подсчёте

С подсчётом связаны две ошибки, которые встречаются чаще других. Первая — путаница между подстрокой и словом: s.count('молоко') найдёт «молоко» и внутри «молоковенный». Вторая — подстрока с разделителем: если искать «молоко,» вместо «молоко», одно из вхождений не посчитается, потому что после последнего слова запятой нет.

order = 'молоко, хлеб, молоко'
print(order.count('молоко'))
print(order.count('молоко,'))
print('молоковенный'.count('молоко'))

2
1
1

Первая строка даёт 2 — молока в заказе действительно два. Вторая даёт 1: после последнего «молоко» запятой нет, и оно не совпало. Третья показывает цену подстрочного поиска: «молоковенный» содержит «молоко» в начале, и count находит его, хотя речь шла о другом слове. Отсюда правило: если считаете СЛОВА — режьте на список и считайте по нему; если считаете ПОДСТРОКИ — помните, что разделитель часть искомого.

И третья ошибка, о которой стоит сказать отдельно, потому что она не про count, а про понимание задачи. «Сколько раз встречается слово» и «сколько слов в тексте» — это разные вопросы, хотя оба про подсчёт. Первый: s.split().count('слово'). Второй: len(s.split()). Перепутать их — значит ответить не на тот вопрос, и никакой count это не исправит.