Метод count() в Python

Продвинутые программисты часто используют дополнительные инструменты к языкам программирования, потому что встроенные возможности не подходят. Иногда не хватает скорости, иногда особого алгоритма действий или интерфейса.

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

Сегодня с примерами разбираем один такой базовый метод в языке Python — count.

Введение в метод count()

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

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

Встречая метод count(), Python понимает, что сейчас ему покажут конкретный элемент и скажут: «Посчитай, сколько раз он встречается в этой конкретной коллекции».

Дальше посмотрим, как это выглядит в коде.

Синтаксис метода count()

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

Например, здесь мы вызываем метод у списка:

print([‘Болтун’, ‘Фенстер’, ‘Китон’, ‘Фенстер’].count(‘Болтун’))
print([‘Болтун’, ‘Фенстер’, ‘Китон’, ‘Фенстер’].count(‘Фенстер’))
print([‘Болтун’, ‘Фенстер’, ‘Китон’, ‘Фенстер’].count(‘Китон’))

Теперь, если вызвать этот код, на каждой строке мы увидим, сколько раз встречается в списке каждый элемент:

1
2
1

Но в коде этого чаще всего не будет видно явно, потому что список (или другую коллекцию) мы предварительно присваиваем в переменную, чтобы сократить количество кода:

usual_suspects = [‘Болтун’, ‘Фенстер’, ‘Китон’, ‘Фенстер’]

А потом уже у этой переменной вызываем метод, и его результат тоже сохраняем в отдельную переменную:

# создаём список
usual_suspects = ['Болтун', 'Фенстер', 'Китон', 'Фенстер']
# сохраняем в переменную количество
# вхождений в список элемента "Болтун"
verbal_count = usual_suspects.count('Болтун')
# выводим результат на экран
print(f'Имя «Болтун» встречается в списке {verbal_count} раз')

В итоге мы получаем тот же результат. Здесь он оформлен более аккуратно:

Имя «Болтун» встречается в списке 1 раз

Параметры метода count()

Метод принимает один параметр — элемент, для которого нужно подсчитать количество вхождений в коллекцию.

Вот некоторые коллекции, у которых можно вызвать count():

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

Элемент-параметр для подсчёта идёт в скобках после ключевого слова count:

count(element)

Возвращаемое значение метода count()

Метод всегда будет возвращать целое число или 0, потому что количество вхождений не может быть дробным и отрицательным: символ или элемент списка могут встречаться 0, 1, 10 или 1000 раз, но не −1 или 2,5.

Примеры использования метода count()

Принцип функции простой, но при разных задачах и типах данных немного различается. Чтобы запомнить и понять, как это работает, мы разберём несколько примеров небольших программ и посмотрим на результаты запуска.

Подсчёт вхождений в списке

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

Пример 1: Подсчёт чисел

Если список состоит из чисел, в качестве параметра мы передаём одно из них:

# создаём список чисел
elements = [1, 2, 3, 2, 4, 2, 5]
# считаем, сколько раз число 2 встречается в списке
number = elements.count(2)
# выводим результат
print("Число 2 встречается:", number, "раз(а)")

Метод проходит по списку и говорит, сколько раз встречается число:

Число 2 встречается: 3 раз(а)

Пример 2: Подсчёт строк

Создаём список из строк и считаем количество нужной через метод count():

# создаём список
game_char = ["Mario", "Luigi", "Mario", "Luigi", "Mario"]
# считаем количество вхождений элемента Mario
mario_count = game_char.count("Mario")
# выводим результат на экран
print(mario_count)

Запускаем и видим, сколько раз в списке встречается Mario:

3

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

В count() нужно передавать именно один элемент. Если передать больше, даже если они идут подряд, получим ошибку.

Несколько элементов можно передать, только если список состоит из вложенных подсписков. В этом случае мы передаём в качестве параметра этот вложенный список:

# создаём список
game_char = [["Mario", "Luigi"], ["Sonic", "Tails"], ["Ryu", "Ken"]]
# считаем количество вхождений вложенного списка
appears = game_char.count(["Mario", "Luigi"])
# выводим результат на экран
print(appears)

Результат в терминале:

1

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

Если в список могут входить любые элементы, то строка всегда состоит из символов. Мы можем искать один символ, а можем сразу несколько.

Пример 3: Подсчёт символов

Сначала научимся искать один символ в строке. Сохраним его в переменную char и будем передавать в метод. Теперь, если мы захотим искать другой символ, его нужно будет заменить только в одном месте — объявления переменной.

# создаём строку
specified = "Use this method, if you want"
# сохраняем в переменную букву, которую будем искать
char = "i"
# считаем, сколько раз символ 'i' встречается в строке
occurrences = specified.count(char)
# выводим результат
print(f"Буква '{char}' встречается:", occurrences, "раз(а)")

Попробуем посмотреть, что выходит в результате:

Буква ‘i’ встречается: 2 раз(а)

Пример 4: Подсчёт подстрок

Теперь попробуем искать сразу последовательность символов — подстроку. 

Это необязательно должны быть отдельные слова. Главное, чтобы символы шли подряд, так же, как они идут в строке.

Смотрим на примере:

# создаём строку
string = ("Открыв статью про метод count, Михаил "
           "увидел странную строку: list, built, times, returns")
# считаем, сколько раз подстрока "list" встречается в строке
substring = string.count("list")
# выводим результат
print("Подстрока 'list' встречается:", substring, "раз(а)")

Проверяем:

Подстрока ‘list’ встречается: 1 раз(а)

Использование метода count() с различными типами данных

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

Нужно только передать их в правильном виде: поставить кавычки для строк, не забыть дробную часть для чисел с плавающей точкой и записать True и False c прописной буквы.

Для примера создадим список с разными типами данных и потренируемся на нём:

# создаём список с разными типами данных
mixed_list = [10, "10", 10.0, 10, True, False, 10]
# считаем, сколько раз встречается число 10 (int)
count_int = mixed_list.count(10)
# считаем, сколько раз встречается строка "10"
count_str = mixed_list.count("10")
# считаем, сколько раз встречается число 10.0 (float)
count_float = mixed_list.count(10.0)
# выводим результаты
print("Целое число 10 встречается:", count_int, "раз(а)")
print("Строка '10' встречается:", count_str, "раз(а)")
print("Число с плавающей точкой 10.0 встречается:", count_float, "раз(а)")

Теперь запустим программу и посмотрим на результаты:

Целое число 10 встречается: 4 раз(а)
Строка ’10’ встречается: 1 раз(а)
Число с плавающей точкой 10.0 встречается: 4 раз(а)

Подсчёт символов в строке с учётом регистра

Метод чувствителен к регистру. Это значит, что если мы передали в качестве параметра строчную букву, Python не засчитает её прописной вариант.

Пример, чтобы убедиться:

# создаём строку
text = "Hello hello HELLO"
# считаем количество заглавных букв 'H'
count_upper = text.count("H")
# считаем количество строчных букв 'h'
count_lower = text.count("h")
# выводим результаты
print("Заглавная 'H' встречается:", count_upper, "раз(а)")
print("Строчная 'h' встречается:", count_lower, "раз(а)")

Что получилось:

Заглавная ‘H’ встречается: 2 раз(а)
Строчная ‘h’ встречается: 1 раз(а)

Подсчёт гласных в строке

Теперь возьмём задачу похитрее и посчитаем количество гласных в тексте.

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

Дополнительно сделаем так, чтобы наш алгоритм не зависел от регистра. Для этого приведём весь текст к нижнему регистру через метод .lower().

Так это выглядит в коде:

# создаём строку
text = "Есть только два типа языков программирования: те, на которые жалуются, и те, которыми никто не пользуется."
# задаём список гласных букв
vowels = "аеёиоуыэюя"
# начинаем подсчёт с нуля
vowel_count = 0
# приводим текст к нижнему регистру
text_lower = text.lower()
# перебираем каждую гласную и добавляем количество её вхождений
for vowel in vowels:
   vowel_count += text.count(vowel)
# выводим результат
print("Количество гласных:", vowel_count)

При запуске программа посчитает все гласные, включая и прописные, и строчные:

Количество гласных: 38

Подсчёт слов в строке

Слова в строке можно искать ещё одним способом: разбить строку на отдельные слова и сделать из них список. После этого проверить этот список на конкретное слово.

Такая программа приводит текст к нижнему регистру, разделяет исходный текст по пробелам между ними и находит в списке заданный элемент-строку:

# создаём строку с несколькими словами
sentence = "Python is simple and python is powerful"
# приводим текст к нижнему регистру
lower_text = sentence.lower()
# разбиваем строку на список слов
words = lower_text.split()
# выбираем слово для подсчёта
target_word = "python"
# считаем, сколько раз это слово встречается в списке
count_word = words.count(target_word)
# выводим результат
print("Слово 'python' встречается:", count_word, "раз(а)")

Результат в терминале:

Слово ‘python’ встречается: 2 раз(а)

Подсчёт подстрок в строке с учётом перекрытий

Перекрытия — это повторяющиеся символы или их последовательности, когда они наслаиваются друг на друга. Например, такая строка:

text = “aaaa”

Если мы попросим count() посчитать количество подстроки aaa, то он найдёт только одно совпадение. Потому что увидит, что длина нужной нам подстроки — 3 символа, и после учёта одного вхождения перескочит сразу на 4-й символ.

Но на самом деле такая подстрока встречается в тексте дважды: начиная с 1-го элемента и со 2-го. Чтобы посчитать вхождения с перекрытиями, нужно немного усложнить логику. Для этого мы проверим каждый символ в тексте по одному, не перескакивая:

# создаём строку
text = "aaaa"

# создаём переменную для подсчёта
count = 0

# перебираем индексы строки
for i in range(len(text)):
    # проверяем, есть ли подстрока «aa», начиная с позиции i
    if text.startswith("aaa", i):
        count += 1

# выводим результат
print("Подстрока 'aaa' встречается с учётом перекрытий:", count, "раз(а)")

Теперь Питон нашёл оба вхождения:

Подстрока ‘aaa’ встречается с учётом перекрытий: 2 раз(а)

Подсчёт уникальных элементов в списке

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

Как это использовать с методом count():

# создаём список чисел с повторениями
numbers = [4, 5, 6, 4, 7, 5, 8, 6]

# перебираем уникальные элементы с помощью set()
for num in set(numbers):
   # для каждого числа считаем количество вхождений
   print(f"Число {num} встречается {numbers.count(num)} раз(а)")

Что получилось при запуске:

Число 4 встречается 2 раз(а)
Число 5 встречается 2 раз(а)
Число 6 встречается 2 раз(а)
Число 7 встречается 1 раз(а)
Число 8 встречается 1 раз(а)

Вам слово

Приходите к нам в соцсети поделиться своим мнением о статье и почитать, что пишут другие. А ещё там выходит дополнительный контент, которого нет на сайте — шпаргалки, опросы и разная дурка. В общем, вот тележка, вот ВК — велком!