Что такое count() в Python, как он работает и что с ним можно посчитать

Метод count() в Python — встроенный способ узнать, какое количество элементов встречается в последовательности: строке, списке или кортеже. Он выручает, когда нужно быстро оценить частоту повторов. Например, посчитать пробелы, проверить, сколько раз встречается слово error в логе, или узнать, сколько нулей оказалось в списке после обработки данных.

В этой статье мы разберём синтаксис метода count(), посмотрим, как он работает с разными типами данных, и объясним всё на понятных примерах.

Содержание

• Синтаксис и принцип работы count() в Python
• Метод count() для строк

• Подсчёт символов
• Подсчёт подстрок и слов
• Поиск вхождений в части строки
• Особенности работы с текстом

• Метод count() для списков в Python

• Подсчёт количества вхождений элемента
• Подсчёт повторяющихся значений
• Применение при обработке данных

• Метод count() для кортежей и байтовых строк
• Чем заменить count() в Python

Синтаксис и принцип работы count() в Python

Поведение метода count() зависит от типа данных. В строках он считает непересекающиеся вхождения подстроки, поэтому символы, которые вошли в найденное совпадение, не участвуют в следующем поиске. Если взять строку aaaa и поискать в ней подстроку aa, count() вернёт 2, а не 3.

Синтаксис метода count() для строк в Python:

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

У строкового count() есть один обязательный параметр sub, который задаёт подстроку для поиска. Также у метода есть два опциональных параметра — start и end. Они задают границы диапазона (индекс end в него не входит) и позволяют посчитать количество вхождений только в нужном фрагменте.

В списках и кортежах метод проходит по элементам, сравнивает их с заданным значением через == и считает, сколько раз оно встречается.

sequence.count(value)

В отличие от строк, у count() для списков и кортежей есть только один параметр — value. Это искомое значение любого типа (например, 0, a или None), с которым элементы последовательности сравниваются через оператор ==.

Для некоторых итерируемых объектов, например range(), метода count() нет. В таком случае вы можете преобразовать объект в список (list(obj)) и вызвать count() у списка. Ещё один вариант — посчитать количество совпадений с помощью генераторного выражения: sum(1 for x in obj if x == value).

При этом во всех случаях count() в Python проходит по последовательности целиком и возвращает количество вхождений — или 0, если совпадений нет.

Читайте также:

Типы данных в Python для начинающих: какие бывают и как с ними работать

Метод count() для строк

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

Подсчёт символов

Чаще всего count() используют, чтобы посчитать символы в строке. В этом случае аргументом будет строка из одного символа. В примере ниже метод показывает, сколько раз в слове «программирование» встречаются символы «р» и «м». А для z count() возвращает 0, поскольку такого символа в строке нет.

text = "программирование"
print(text.count("р"))  # 3
print(text.count("м"))  # 2
print(text.count("z"))  # 0

Подсчёт подстрок и слов

Метод count() подходит для поиска любых подстрок. Но он не учитывает границы слов и посчитает совпадения даже внутри других слов. В следующем примере кот встречается дважды как отдельное слово, а также входит в слова котёнок и котище — всего получится четыре вхождения.

sentence = "кот котёнок кот котище"
print(sentence.count("кот"))  # 4

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

sentence = "кот котёнок кот котище"

# Разбиваем на слова
words = sentence.split()
print(words.count("кот"))  # 2

# Используем регулярное выражение 
import re
print(len(re.findall(r"\bкот\b", sentence)))  # 2

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

Необязательные параметры start и end сужают область поиска: так, с их помощью можно посчитать количество вхождений только в середине текста. Эти параметры могут быть отрицательными — тогда отсчёт ведётся с конца строки: -1 означает последний символ, -2 — предпоследний и так далее.

Давайте теперь разберём, как работают start и end в разных ситуациях — от диапазонов до отрицательных индексов и выходов за пределы строки.

text = "programming"

# Диапазон [3:10]: text[3:10] = "grammin"
print(text.count("m", 3, 10))  # m встречается два раза

# Только start: text[4:] = "amming"
print(text.count("g", 4))  # g встречается один раз

# Отрицательные индексы: text[-5:-1] = "mmin" 
print(text.count("m", -5, -1))  # m встречается два раза

# end больше длины строки — фактически считаем в text[0:]
print(text.count("r", 0, 100))  # r встречается два раза

# start больше длины строки — диапазон пустой 
print(text.count("g", 100))  # Количество значений всегда равно 0

Особенности работы с текстом

Метод count() чувствителен к регистру, поэтому строки python и Python для него разные. Если нужно учесть все варианты написания, строку заранее нормализуют — приводят к одному регистру с помощью lower() или upper().

text = "Python PYTHON python"

# Ищем только совпадения в нижнем регистре
print(text.count("python"))  # 1

# Учитываем количество всех вариантов написания
print(text.lower().count("python"))  # 3

Кроме того, count() корректно работает и с многострочным текстом: символ переноса строки \n считается обычным символом и тоже участвует в поиске.

multiline = "строка 1\nстрока 2\nстрока 1"
print(multiline.count("строка 1"))  # 2

Отдельно упомянем пустую подстроку "": если передать её в count(), метод вернёт len(string) + 1 — количество позиций между символами, включая начало и конец строки. Поведение неочевидное, поэтому будьте осторожны.

print("abc".count(""))  # 4

Читайте также:

Методы и функции строк в Python

Метод count() для списков в Python

Если у вас есть список элементов, метод count() может пригодиться во многих сценариях — от валидации ввода до подсчёта количества значений, предобработки данных и поиска дублей. Далее посмотрим, как он работает.

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

Метод count(value) подсчитает, сколько раз значение value встречается в списке. В примере ниже яблоко встречается трижды, а груша отсутствует.

fruits = ["яблоко", "банан", "яблоко", "апельсин", "яблоко"]
print(fruits.count("яблоко"))  # 3
print(fruits.count("груша"))   # 0

Метод сравнивает элементы через ==, поэтому для встроенных типов сравнение идёт по значению, а не по ссылке. При этом count() учитывает лишь точные совпадения. Например, в списке words строка cat встречается один раз: элемент caterpillar не считается, хоть и содержит подстроку cat.

words = ["cat", "caterpillar"] 
print(words.count("cat")) # 1 

Подсчёт повторяющихся значений

Чтобы найти элементы, которые встречаются больше одного раза, count() удобно сочетать с множеством. Работает это так: сначала мы получаем уникальные значения, а затем отбираем те, у которых count() больше 1.

Для примера создадим список numbers, затем превратим его в множество, чтобы получить уникальные значения. После этого с помощью генератора списка оставим только те элементы, которые встречаются в исходном списке больше одного раза. В результате в список дубликатов попадут числа 2 и 4.

numbers = [1, 2, 2, 3, 4, 4, 4, 5] unique_numbers = set(numbers) duplicates = [x for x in unique_numbers if numbers.count(x) > 1] print(duplicates) # [2, 4]

Применение при обработке данных

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

Самым непривычным здесь может показаться расчёт пропусков. В этом случае нужно посчитать количество None и сравнить его с числом элементов. В коде ниже мы делаем именно это: считаем, сколько раз встречается None, и, если доля превышает 30%, выводим предупреждение.

records = [1, None, 3, None, None, 5]
if records.count(None) > len(records) * 0.3:
    print("Слишком много пропущенных значений") # Слишком много пропущенных значений

Читайте также:

Списки в Python: что это такое и как с ними работать

Метод count() для кортежей и байтовых строк

Для кортежей count() работает так же, как и для списков: метод проходит по всей последовательности, сравнивает элементы с искомым значением через оператор == и возвращает количество вхождений. В следующем примере значение 2 встречается в кортеже три раза, поэтому t.count(2) возвращает 3.

t = (1, 2, 3, 2, 4, 2)
print(t.count(2)) # 3
print(t.count(5)) # 0

Также стоит учитывать, что кортежи можно использовать для хранения разнородных данных — например, записей из базы данных или строк из CSV‑файла. В таких случаях count() помогает узнать, как часто встречается конкретное значение или запись, не преобразуя эти данные в список.

records = (
    ("Иван", 25),
    ("Мария", 30),
    ("Иван", 25),
    ("Пётр", 40),
)
print(records.count(("Иван", 25))) # 2

Метод count() пригодится и при работе с двоичными данными. Для этого в Python есть байтовые строки bytes и их изменяемый вариант bytearray — например, так часто представляют содержимое файла или сетевого пакета.

Синтаксис здесь такой же, как у строк, только вместо символов метод ищет байты или их последовательность. Как и в случае со строками, вы можете ограничить диапазон поиска, если передадите параметры start и end.

data = b"hello world"
print(data.count(b"l")) # 3
print(data.count(b"lo")) # 1

ba = bytearray(b"abracadabra")
print(ba.count(b"a")) # 5

В примере выше мы создаём объект типа bytes и считаем, сколько раз в нём встречается байт b"l". Затем подсчитываем число вхождений последовательности байтов b"lo". После создаём объект типа bytearray (переменная ba) и смотрим, сколько раз в нём встречается байт b"a".

Читайте также:

Бит и байт: гайд по единицам измерения информации

Чем заменить count() в Python

Хотя count() — простой метод, он подходит не для всех задач. Например, у некоторых объектов его нет, иногда нужно считать количество элементов по составному условию, а повторные вызовы count() могут заметно замедлять код из‑за квадратичной сложности. В таких случаях пригодятся альтернативы.

В первую очередь стоит выделить цикл — это самый наглядный способ подсчёта для любой логики, которая не сводится к простому равенству.

Например, если нам нужно посчитать, сколько в списке чётных чисел больше 30, count() не поможет: он умеет считать только точные вхождения конкретного значения. А цикл позволяет проверить условие для каждого элемента и увеличить счётчик только тогда, когда условие выполняется. В примере ниже таким числом оказывается только 42, поэтому результат — 1.

data = [10, 23, 35, 42, 57]
count = 0
for x in data:
    if x % 2 == 0 and x > 30: # Чётные и больше 30
        count += 1
print(count) # 1 (42)

Кроме цикла, отметим генераторное выражение с sum(), которое мы уже встречали. Это более лаконичный способ подсчёта: оно не создаёт промежуточный список и подходит для любых условий, а не только для точного равенства. В примере ниже мы считаем, сколько раз в списке встречается число 5, а затем — сколько значений в диапазоне от 10 до 20.

numbers = [1, 5, 3, 5, 2, 5]
count = sum(1 for x in numbers if x == 5)
print(count) # 3

values = [15, 22, 8, 31, 5, 19]
in_range = sum(1 for v in values if 10 <= v <= 20)
print(in_range) # 2

Ещё одна альтернатива — класс‑счётчик Counter из модуля collections. Он выручает, когда нужно посчитать частоты всех элементов сразу: Counter делает один проход по данным и формирует объект наподобие словаря, где ключ — элемент, а значение — число его вхождений. После этого к частоте любого элемента вы можете обращаться так же, как к значению в словаре.

from collections import Counter

data = [1, 2, 2, 3, 3, 3]
counter = Counter(data)
print(counter[2]) # 2
print(counter[5]) # 0

Если подытожить, то count() подходит, когда нужно посчитать одно значение в небольшой последовательности. Counter удобнее, когда важно сразу получить распределение — например, найти самый частый элемент, выделить дубликаты или быстро проверить, какие элементы вообще встречаются в данных. А для генераторов и потоковых данных, которые нельзя хранить целиком, используйте цикл или генераторное выражение.

Читайте также:

Циклы в Python: как работают и какие бывают