Как посчитать количество символов в строке python

строку — посчитать количество символов в строке python

питон использует только первую букву (6)

Вот один лайнер, который будет содержать верхний регистр первой буквы и оставить случай всех последующих букв:

Это приведет к WordsWithOtherUppercaseLetters

Я знаю .capitalize () заглавные буквы первой буквы строки, но что, если первый символ является целым числом?

Вы можете заменить первую букву ( preceded by a digit ) каждого слова, используя регулярное выражение:

Как видно here , Чэнь Хоуу, можно использовать пакет строк:

Только потому, что никто не упомянул об этом:

Однако это также даст

т.е. он не просто использует первый алфавитный символ. Но тогда .capitalize() имеет ту же проблему, по крайней мере, в том, что ‘joe Bob’.capitalize() == ‘Joe bob’ , так что meh.

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

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

Метод № 1: Наивный метод

Итерируйте всю строку для этого конкретного символа, а затем увеличивайте счетчик, когда мы сталкиваемся с конкретным символом.

# Python3 код для демонстрации
# частота появления с использованием
# наивный метод

# используя наивный метод для подсчета
# считая е

for i in test_str:

count = count + 1

print ( «Count of e in GeeksforGeeks is : «

Выход :

Способ № 2: Использование count()

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

# Python3 код для демонстрации
# частота появления с использованием
# count ()

# используя count () чтобы получить счет
# считая е

counter = test_str.count( ‘e’ )

print ( «Count of e in GeeksforGeeks is : «

Выход :

Способ № 3: Использование collections.Counter()

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

# Python3 код для демонстрации
# частота появления с использованием
# collection.Counter ()

from collections import Counter

# использование collection.Counter () для подсчета
# считая е

print ( «Count of e in GeeksforGeeks is : «

Выход :

Способ № 4: Использование лямбда + sum() + map()

Лямбда-функции вместе с sum() и map() могут решить эту конкретную задачу подсчета общего числа вхождений определенного элемента в строку. Он использует sum() для суммирования всех вхождений, полученных с помощью map() .

# Python3 код для демонстрации
# частота появления с использованием
# лямбда + сумма () + карта ()

# используя лямбда + сумма () + карта () для подсчета
# считая е

count = sum ( map ( lambda x : 1 if ‘e’ in x else 0 , test_str))

print ( «Count of e in GeeksforGeeks is : «

Выход :

Способ № 5: Использование re + findall()

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

# Python3 код для демонстрации
# частота появления с использованием
# re + findall ()

Подсчет повторяющихся символов в строке в Python

Я хочу подсчитать количество повторений каждого символа в строке. Есть ли какой-либо конкретный способ сделать это, кроме сравнения каждого символа строки с A-Z и увеличение счетчика?

Обновить (ссылаясь на Anthony answer): Что бы вы ни предлагали до сих пор, мне приходится писать 26 раз. Есть ли более простой способ?

ОТВЕТЫ

Ответ 1

Моя первая идея состояла в том, чтобы сделать это:

Однако это не очень хорошая идея! Это будет проверять строку 26 раз, поэтому вы будете потенциально выполнять в 26 раз больше работы, чем некоторые другие ответы. Вы действительно должны это сделать:

Это гарантирует, что вы проходите только строку один раз, а не 26 раз.

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

Ответ 2

A collections.defaultdict похож на dict (подклассы он на самом деле), но когда запись запрашивается и не найдена, вместо того, чтобы сообщать, что она ее не имеет, она делает ее и вставляет ее, вызывая предоставленную 0-аргумент вызываемый. Наиболее популярными являются defaultdict(int) , для подсчета (или, что то же самое, для создания структуры данных мультисети AKA) и defaultdict(list) , что навсегда избавляет от необходимости использовать .setdefault(akey, []).append(avalue) и подобные неудобные идиомы.

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

Ответ 3

Python 2.7+ включает collections.Counter класс:

Ответ 4

Великолепное сравнение производительности

Поскольку у меня не было «ничего лучше» (понимаю: у меня было много работы), я решил сделать небольшой конкурс производительности. Я собрал самые разумные или интересные ответы и сделал некоторые простые timeit в CPython 3.5.1 на них. Я проверил их только с одной строкой, которая типичный вход в моем случае:

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

Не изобретайте велосипед

Python сделал это простым для нас. Класс collections.Counter делает именно то, что мы хотим и многое другое. Его использование на сегодняшний день является самым простым из всех методов, упомянутых здесь.

взят из @oefe, хорошая находка

Counter проходит лишнюю милю, поэтому так долго.

¿Словарь, comprende?

Давайте попробуем вместо этого использовать простой dict . Во-первых, давайте сделаем это декларативно, используя dict понимание.

Я сам придумал это.

Это будет проходить через s от начала до конца, и для каждого символа он будет считать число его вхождений в s . Поскольку s содержит повторяющиеся символы, вышеуказанный метод выполняет поиск s несколько раз для одного и того же персонажа. Результат, естественно, всегда одинаков. Так что давайте считать количество вхождений только один раз для каждого символа.

Я сам придумал это, как и @IrshadBhat.

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

Исключительный код

Ака Должен поймать их всех!

вдохновленный @anthony

Ну, это стоило попробовать. Если вы покопаетесь в источнике Python (я не могу сказать с уверенностью, потому что Я никогда не делал этого на самом деле), вы, вероятно, обнаружите, что когда вы делаете except ExceptionType , Python должен проверить, действительно ли возникшее исключение относится к ExceptionType или другому тип. Просто, черт возьми, давайте посмотрим, сколько времени это займет, если мы пропустим эту проверку и поймать все исключения.

сделано @anthony

Это экономит некоторое время, поэтому можно испытать искушение использовать это как своего рода оптимизацию.
Не делай этого! Или на самом деле. Сделай это сейчас:

ИНТЕРЛЮД 1

Видишь? Ловит KeyboardInterrupt , кроме прочего. На самом деле, он ловит все исключения есть. Включая те, о которых вы, возможно, даже не слышали, например, SystemExit .

ИНТЕРЛЮД 2

Теперь вернемся к подсчету букв, цифр и других символов.

Игра в догонялки

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

Класс dict имеет хороший метод — get , который позволяет нам извлечь элемент из словарь, как и d[k] . За исключением случаев, когда ключ k отсутствует в словаре, он может вернуть значение по умолчанию. Давайте использовать этот метод вместо того, чтобы возиться с исключениями.

кредит идет на @Usman

Почти так же быстро, как и основанное на множестве понимание. На больших входах этот, вероятно, будет еще быстрее.

Используйте правильный инструмент для работы

По крайней мере, для слегка осведомленного программиста на Python первое, что приходит на ум, это вероятно defaultdict . Он делает то же самое, что и версия выше, за исключением того, что вместо значения, вы даете ему значение фабрики. Это может вызвать некоторые накладные расходы, потому что значение имеет быть «построенным» для каждого недостающего ключа индивидуально. Давайте посмотрим, как это работает.

надеюсь, что @AlexMartelli меня не распят за from collections import defaultdict

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

снимаю шляпу перед @sqram

Это хорошо. В три раза быстрее, чем Counter , но все же достаточно просто. Лично это мой любимый на случай, если вы не хотите добавлять новых персонажей позже. И даже если вы делаете, вы можете все еще делай это. Это менее удобно, чем в других версиях:

Практичность превосходит чистоту (кроме случаев, когда это не очень практично)

Теперь немного другой вид счетчика. @IdanK придумал что-то интересное. Вместо использования хеш-таблицы (a.k.a. словарь a.k.a. dict ), мы можем избежать риска хеш-конфликтов и последующие накладные расходы на их решение. Мы также можем избежать издержек хэширования ключа, и дополнительное свободное место в таблице. Мы можем использовать list . Значения символов ASCII будут индексы и их количество будут значениями. Как указал @IdanK, этот список дает нам постоянный время доступа к количеству символов. Все, что нам нужно сделать, это преобразовать каждый символ из str в int с использованием встроенной функции ord . Это даст нам индекс в списке, который мы будем затем используйте для увеличения количества символов. Так что мы делаем это: мы инициализируем список с нулями сделайте работу, а затем преобразуйте список в dict . Этот dict будет содержать только те символы, которые имеют ненулевое значение, чтобы сделать его совместимым с другими версиями.

В качестве примечания, этот метод используется в алгоритме сортировки по линейному времени, известному как счетная сортировка или счетная сортировка. Это очень эффективно, но диапазон значений сортируется ограничено, так как каждое значение должно иметь свой собственный счетчик. Чтобы отсортировать последовательность из 32-разрядных целых чисел, Потребуется 4,3 миллиарда счетчиков.

Ой! Не круто! Давайте попробуем и посмотрим, сколько времени понадобится, когда мы не будем строить словарь.

Все еще плохо. Но подождите, что [0 for _ in range(256)] ? Разве мы не можем написать это проще? Как насчет [0] * 256 ? Это чище. Но будет ли он лучше?

Радикально. Теперь давайте вернем словарь обратно.

Почти в шесть раз медленнее. Почему это так долго? Потому что, когда мы enumerate(counts) , мы имеем проверить каждый из 256 отсчетов и посмотреть, равен ли он нулю. Но мы уже знаем, какие цифры ноль, а которые нет.

Это, вероятно, не станет намного лучше, по крайней мере, для такого маленького вклада. Плюс это только можно использовать для 8-битных символов EASCII. О блять!

И победитель.

Угу. Даже если вам нужно каждый раз проверять, находится ли c в d , для этого входа он самый быстрый путь. Никакое предварительное заполнение d не сделает его быстрее (опять же, для этого ввода). Это намного больше более подробный, чем Counter или defaultdict , но также более эффективный.

Это все люди

Это небольшое упражнение учит нас уроку: при оптимизации всегда измеряйте производительность, в идеале с вашими ожидаемыми входами. Оптимизировать для общего случая. Не думайте, что что-то на самом деле более эффективен только потому, что его асимптотическая сложность ниже. И последнее, но не менее важное удобочитаемость. Попробуйте найти компромисс между «дружественным к компьютеру» и «дружественным для человека».

UPDATE

@MartijnPieters сообщил мне о функции collections._count_elements доступно в Python 3.

Эта функция реализована в C, поэтому она должна быть быстрее, но эта дополнительная производительность приходит по цене. Цена несовместима с Python 2 и, возможно, даже будущими версиями, так как мы используем приватную функцию.

[. ] имя с префиксом подчеркивания (например, _spam ) следует рассматривать как непубличную часть API (будь то функция, метод или элемент данных). Это следует считать деталями реализации и могут быть изменены без предварительного уведомления.

Тем не менее, если вы все еще хотите сохранить эти 620 наносекунд на итерацию:

ОБНОВЛЕНИЕ 2: большие строки

Я подумал, что будет хорошей идеей перезапустить тесты на более крупном вводе, так как 16 символов Строка настолько мала, что все возможные решения были сравнительно быстрыми (1000 итераций менее чем за 30 миллисекунд).

Я решил использовать полное собрание сочинений Шекспира в качестве тестового корпуса, что оказалось довольно сложной задачей (так как его размер превышает 5 МБ ). Я просто использовал первый 100 000 символов, и мне пришлось ограничить количество итераций от 1 000 000 до 1 000.

collections.Counter был очень медленным на небольшом входе, но таблицы перевернулись

Наивное Θ (n 2 ) словарь времени просто не работает

Умный Θ (n) словарь времени работает хорошо

Исключения неуклюжи и медленны

Пропуск проверки типа исключения не экономит время (поскольку исключение выдается только несколько раз)

dict.get выглядит хорошо, но работает медленно

collections.defaultdict тоже не очень быстрый

dict.fromkeys требует прочитать (очень длинную) строку дважды

Использование list вместо dict не слишком хорошо и не быстро

Выход из окончательного преобразования в dict не помогает

Неважно, как вы построите list , так как это не узкое место

Если вы конвертируете list в dict «умным» способом, он будет еще медленнее (поскольку вы выполняете итерацию по строка дважды)

Вариант dict.__contains__ может быть быстрым для маленьких строк, но не так много для больших

collections._count_elements примерно так же быстро, как collections.Counter (который использует _count_elements изнутри)

Окончательный вердикт: используйте collections.Counter , если вы не можете или не хотите 🙂

Приложение: NumPy

Пакет numpy предоставляет метод numpy.unique , который выполняет (почти) именно то, что мы хотим.

Способ работы этого метода сильно отличается от всех вышеперечисленных методов:

Сначала сортируется копия входных данных с использованием быстрой сортировки, что составляет O (n 2 ) время операция в худшем случае, хотя O (n log n) в среднем и O (n) в лучшем случае.

Затем он создает массив «mask», содержащий True по индексам, где выполняется ряд одинаковых значений. начинается, а именно в индексах, где значение отличается от предыдущего значения. Повторные значения производят False в маске. Пример: [5,5,5,8,9,9] создает маску [True, False, False, True, True, False] .

Затем эта маска используется для извлечения уникальных значений из отсортированного ввода — unique_chars в код ниже. В нашем примере это будет [5, 8, 9] .

Позиции значений True в маске взяты в массив, а длина входного добавляется в конце этого массива. Для приведенного выше примера этот массив будет [0, 3, 4, 6] .

Для этого массива вычисляются различия между его элементами, например. [3, 1, 2] . Эти соответствующее количество элементов в отсортированном массиве — char_counts в приведенном ниже коде.

Наконец, мы создаем словарь, архивируя unique_chars и char_counts : .

Для тестового ввода (первые 100 000 символов из полного сочинения Шекспира) этот метод работает лучше, чем любой другой тестированный здесь. Но обратите внимание, что на с другой стороны, этот подход может дать худшую производительность, чем другие методы. Предварительная сортировка ввода и количество повторений на элемент являются важными факторами, влияющими на производительность.

Если вы думаете об использовании этого метода, потому что он в два раза быстрее, чем collections.Counter , учтите это:

collections.Counter имеет линейную сложность по времени. numpy.unique в лучшем случае линейный, квадратичный в худшем случае.

Ускорение не так уж существенно — вы экономите

3,5 миллисекунды за итерацию на входе длиной 100 000.

Использование numpy.unique очевидно требует numpy .

Учитывая это, кажется разумным использовать Counter , если вам не нужно быть очень быстрым. И в в этом случае вам лучше знать, что вы делаете, иначе вы будете медленнее работать с numpy , чем без этого.

Ответ 5

Это самый короткий, самый практичный, с которым я могу работать без импорта дополнительных модулей.

print d [‘a’] выводит 2

И это также быстро.

Ответ 6

Вы хотите использовать dict.

Ответ 7

Если кто-то ищет самый простой способ без модуля collections . Я думаю, это будет полезно:

Ответ 8

Вы можете использовать словарь:

Ответ 9

Я могу подсчитать количество дней, когда я знаю Python на моих двух руках, поэтому простите меня, если я отвечу на что-то глупое:)

Вместо использования dict я подумал, почему не использовать список? Я не уверен, как списки и словари реализованы на Python, поэтому это нужно измерить, чтобы узнать, что быстрее.

Если бы это был С++, я бы просто использовал обычный c-array/vector для постоянного доступа времени (это определенно было бы быстрее), но я не знаю, какой соответствующий тип данных находится в Python (если есть. )

Также можно сделать размер списка ord (‘z’), а затем избавиться от вычитания 97 всюду, но если вы оптимизируете, почему бы не полностью:)

EDIT: Один комментатор предположил, что соединение/раскол не стоит возможного выигрыша в использовании списка, поэтому я подумал, почему бы не избавиться от него:

Ответ 10

Если моя строка:

Над кодом будет напечатан:

Ответ 11

это покажет букву символов с числом встречаемости

Ответ 12

Ответ 13

Если это проблема просто подсчета количества повторений данного символа в данной строке, попробуйте что-то вроде этого.

Подсчитать количество символов в каждой строке файла

Дан текстовый файл. Подсчитать количество символов в каждой строке
Дан текстовый файл. Подсчитать количество символов в каждой строке. Помогите переделать из.

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

Подсчитать количество символов в каждой строке данного текстового файла
Помогите пожалуйста. Задача 6. Дан текстовый файл. Подсчитать количество символов в каждой.

Подсчитать количество символов в каждой строке
Даны текстовый файл с латиницей и цифрами. Подсчитать количество символов в каждой строке и массив.

Подсчитать количество символов в каждой строке
Дан текстовый файл.Подсчитать количество символов в каждой строке.

Подсчитать количество чисел в каждой строке файла
мне нужно на СИ: Дан текстовый файл, состоящий из одной или нескольких строк. Каждая тсрока файла.

Подсчитать количество слов в каждой строке файла
Дошёл до такого в 24 строке выдаёт ошибку и дальше ещё пару ошибок,помогите разобраться. #include.

Подсчитать количество цифр, встречающихся в каждой строке файла
Создать в редакторе текстовый файл, внести в него 10 строк произвольного текста. Разработать.

Подсчитать количество символов в каждой строке и массив чисел с количествами записать в другой текстовый файл
Данные считываются с текстового файла(1) и записываются в другой(2). Есть текстовый файл с.

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *