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

5

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

Я решаю эту проблему на Hackerrank, и мне пришла в голову идея, которая включает разделение input и присоединитесь к нему позже (см. мою реализацию ниже). Однако один из тестовых примеров содержит ввод ( привет мир ), что привело к сбою моего кода, потому что строка ввода содержит более 1 пробела между словами. Итак, мне просто интересно, может ли кто-нибудь помочь мне исправить мой код, и мне просто интересно, как подсчитать, сколько пробелов (особенно нескольких пробелов) в строке в Python. Я нашел, как считать пробелы в Java, но не в Python. Для тестового случая я прикрепил рис.

Моя реализация:

7 ответов

Вы можете исправить это, разделив шаблон ‘ ‘ (пробел)

Вы также можете использовать метод .capitalize () вместо повторного разделения токена

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

Забудьте о пробелах, это не ваша проблема.
Вы можете сократить строку до слов без лишних пробелов, используя split(None) , что даст вам количество слов и вашу строку, т.е.

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

41 вопрос о работе со строками в Python

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

Быть хорошим программистом — это не значит помнить все встроенные функции некоего языка. Но это не означает и того, что их запоминание — бесполезное дело. Особенно — если речь идёт о подготовке к собеседованию.

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

1. Как проверить два объекта на идентичность?

Оператор is возвращает True в том случае, если в две переменные записана ссылка на одну и ту же область памяти. Именно об этом идёт речь при разговоре об «идентичности объектов».

Не стоит путать is и == . Оператор == проверяет лишь равенство объектов.

Обратите внимание на то, что animals и even_more_animals не идентичны, хотя и равны друг другу.

Кроме того, существует функция id() , которая возвращает идентификатор адреса памяти, связанного с именем переменной. При вызове этой функции для двух идентичных объектов будет выдан один и тот же идентификатор.

2. Как проверить то, что каждое слово в строке начинается с заглавной буквы?

Существует строковый метод istitle() , который проверяет, начинается ли каждое слово в строке с заглавной буквы.

3. Как проверить строку на вхождение в неё другой строки?

Существует оператор in , который вернёт True в том случае, если строка содержит искомую подстроку.

4. Как найти индекс первого вхождения подстроки в строку?

Есть два метода, возвращающих индекс первого вхождения подстроки в строку. Это — find() и index() . У каждого из них есть определённые особенности.

Метод find() возвращает -1 в том случае, если искомая подстрока в строке не найдена.

Метод index() в подобной ситуации выбрасывает ошибку ValueError .

5. Как подсчитать количество символов в строке?

Функция len() возвращает длину строки.

6. Как подсчитать то, сколько раз определённый символ встречается в строке?

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

7. Как сделать первый символ строки заглавной буквой?

Для того чтобы это сделать, можно воспользоваться методом capitalize() .

8. Что такое f-строки и как ими пользоваться?

В Python 3.6 появилась новая возможность — так называемые «f-строки». Их применение чрезвычайно упрощает интерполяцию строк. Использование f-строк напоминает применение метода format() .

При объявлении f-строк перед открывающей кавычкой пишется буква f .

9. Как найти подстроку в заданной части строки?

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

Обратите внимание на то, что вышеприведённая конструкция возвращает 23 , а не 0 , как было бы, не ограничь мы поиск.

10. Как вставить содержимое переменной в строку, воспользовавшись методом format()?

Метод format() позволяет добиваться результатов, сходных с теми, которые можно получить, применяя f-строки. Правда, я полагаю, что использовать format() не так удобно, так как все переменные приходится указывать в качестве аргументов format() .

11. Как узнать о том, что в строке содержатся только цифры?

Существует метод isnumeric() , который возвращает True в том случае, если все символы, входящие в строку, являются цифрами.

Используя этот метод, учитывайте то, что знаки препинания он цифрами не считает.

12. Как разделить строку по заданному символу?

Здесь нам поможет метод split() , который разбивает строку по заданному символу или по нескольким символам.

13. Как проверить строку на то, что она составлена только из строчных букв?

Метод islower() возвращает True только в том случае, если строка составлена исключительно из строчных букв.

14. Как проверить то, что строка начинается со строчной буквы?

Сделать это можно, вызвав вышеописанный метод islower() для первого символа строки.

15. Можно ли в Python прибавить целое число к строке?

В некоторых языках это возможно, но Python при попытке выполнения подобной операции будет выдана ошибка TypeError .

16. Как «перевернуть» строку?

Для того чтобы «перевернуть» строку, её можно разбить, представив в виде списка символов, «перевернуть» список, и, объединив его элементы, сформировать новую строку.

17. Как объединить список строк в одну строку, элементы которой разделены дефисами?

Метод join() умеет объединять элементы списков в строки, разделяя отдельные строки с использованием заданного символа.

18. Как узнать о том, что все символы строки входят в ASCII?

Метод isascii() возвращает True в том случае, если все символы, имеющиеся в строке, входят в ASCII.

19. Как привести всю строку к верхнему или нижнему регистру?

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

20. Как преобразовать первый и последний символы строки к верхнему регистру?

Тут, как и в одном из предыдущих примеров, мы будем обращаться к символам строки по индексам. Строки в Python иммутабельны, поэтому мы будем заниматься сборкой новой строки на основе существующей.

21. Как проверить строку на то, что она составлена только из прописных букв?

Имеется метод isupper() , который похож на уже рассмотренный islower() . Но isupper() возвращает True только в том случае, если вся строка состоит из прописных букв.

22. В какой ситуации вы воспользовались бы методом splitlines()?

Метод splitlines() разделяет строки по символам разрыва строки.

23. Как получить срез строки?

Для получения среза строки используется синтаксическая конструкция следующего вида:

Здесь step — это шаг, с которым будут возвращаться символы строки из диапазона start_index:end_index . Значение step , равное 3, указывает на то, что возвращён будет каждый третий символ.

24. Как преобразовать целое число в строку?

Для преобразования числа в строку можно воспользоваться конструктором str() .

25. Как узнать о том, что строка содержит только алфавитные символы?

Метод isalpha() возвращает True в том случае, если все символы в строке являются буквами.

26. Как в заданной строке заменить на что-либо все вхождения некоей подстроки?

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

27. Как вернуть символ строки с минимальным ASCII-кодом?

Если взглянуть на ASCII-коды элементов, то окажется, например, что прописные буквы имеют меньшие коды, чем строчные. Функция min() возвращает символ строки, имеющий наименьший код.

28. Как проверить строку на то, что в ней содержатся только алфавитно-цифровые символы?

В состав алфавитно-цифровых символов входят буквы и цифры. Для ответа на этот вопрос можно воспользоваться методом isalnum() .

29. Как удалить пробелы из начала строки (из её левой части), из её конца (из правой части), или с обеих сторон строки?

Здесь нам пригодятся, соответственно, методы lstrip() , rstrip() и strip() .

30. Как проверить то, что строка начинается с заданной последовательности символов, или заканчивается заданной последовательностью символов?

Для ответа на этот вопрос можно прибегнуть, соответственно, к методам startswith() и endswith() .

31. Как закодировать строку в ASCII?

Метод encode() позволяет кодировать строки с использованием заданной кодировки. По умолчанию используется кодировка utf-8 . Если некий символ не может быть представлен с использованием заданной кодировки, будет выдана ошибка UnicodeEncodeError .

32. Как узнать о том, что строка включает в себя только пробелы?

Есть метод isspace() , который возвращает True только в том случае, если строка состоит исключительно из пробелов.

33. Что случится, если умножить некую строку на 3?

Будет создана новая строка, представляющая собой исходную строку, повторённую три раза.

34. Как привести к верхнему регистру первый символ каждого слова в строке?

Существует метод title() , приводящий к верхнему регистру первую букву каждого слова в строке.

35. Как объединить две строки?

Для объединения строк можно воспользоваться оператором + .

36. Как пользоваться методом partition()?

Метод partition() разбивает строку по заданной подстроке. После этого результат возвращается в виде кортежа. При этом подстрока, по которой осуществлялась разбивка, тоже входит в кортеж.

37. Строки в Python иммутабельны. Что это значит?

То, что строки иммутабельны, говорит о том, что после того, как создан объект строки, он не может быть изменён. При «модификации» строк исходные строки не меняются. Вместо этого в памяти создаются совершенно новые объекты. Доказать это можно, воспользовавшись функцией id() .

При конкатенации ‘Rise each day before the sun’ и ‘ if its a weekday’ в памяти создаётся новый объект, имеющий новый идентификатор. Если бы исходный объект менялся бы, тогда у объектов был бы один и тот же идентификатор.

38. Если объявить одну и ту же строку дважды (записав её в 2 разные переменные) — сколько объектов будет создано в памяти? 1 или 2?

В качестве примера подобной работы со строками можно привести такой фрагмент кода:

При таком подходе в памяти создаётся лишь один объект. Когда я столкнулся с этим в первый раз, мне это не показалось интуитивно понятным. Но этот механизм помогает Python экономить память при работе с длинными строками.

Доказать это можно, прибегнув к функции id() .

39. Как пользоваться методами maketrans() и translate()?

Метод maketrans() позволяет описать отображение одних символов на другие, возвращая таблицу преобразования.

Метод translate() позволяет применить заданную таблицу для преобразования строки.

Обратите внимание на то, что в строке произведена замена символов a , b , c и s , соответственно, на символы 1 , 2 , 3 и S .

40. Как убрать из строки гласные буквы?

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

41. В каких ситуациях пользуются методом rfind()?

Метод rfind() похож на метод find() , но он, в отличие от find() , просматривает строку не слева направо, а справа налево, возвращая индекс первого найденного вхождения искомой подстроки.

Итоги

Я часто объясняю одному продакт-менеджеру, человеку в возрасте, что разработчики — это не словари, хранящие описания методов объектов. Но чем больше методов помнит разработчик — тем меньше ему придётся гуглить, и тем быстрее и приятнее ему будет работаться. Надеюсь, теперь вы без труда ответите на рассмотренные здесь вопросы.

Уважаемые читатели! Что, касающееся обработки строк в Python, вы посоветовали бы изучить тем, кто готовится к собеседованию?

Python 3: Строки. Функции и методы строк¶

Определение позиции подстроки в строке с помощью функций str.find и str.rfind .

Функция str.find показывает первое вхождение подстроки. Все позиции возвращаются относительно начало строки.

Можно определить вхождение в срезе. первое число показывает начало среза, в котором производится поиск. Второе число — конец среза. В случае отсутствия вхождения подстроки выводится -1.

Функция str.rfind осуществляет поиск с конца строки, но возвращает позицию подстроки относительно начала строки.

Python: Извлекаем имя файла из URL¶

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

Способ №1¶

Достаточно простой способ. Разбиваем строку по слэшам с помощью функции split() , которая возвращает список. А затем из этого списка извлекаем последний элемент. Он и будет названием файла.

Повторим шаг с присвоением переменной:

Способ №2¶

Второй способ интереснее. Сначала с помощью функции rfind() находим первое вхождение с конца искомой подстроки. Функция возвращает позицию подстроки относительно начала строки. А далее просто делаем срез.

Строки и символьные данные в Python

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

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

Вы также познакомитесь с двумя другими объектами Python, используемыми для представления необработанных байтовых данных, типами bytes и bytearray .

Обработка строк

В следующих разделах описаны операторы, методы и функции, доступные для работы со строками.

Операторы строк

Вы уже видели операторы + и * , применяемые к числовым операндам в уроке по операторам и выражениям в Python. Эти два оператора могут быть применены и к строкам.

Оператор +

Оператор + объединяет строки. Он возвращает строку, состоящую из операндов, соединенных вместе, как показано здесь:

Оператор *

Оператор * создает несколько копий строки. Если s -строка, а n -целое число, то любое из следующих выражений возвращает строку, состоящую из n сцепленных копий s :

Вот примеры обеих форм:

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

Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение ‘foo’ * -8 , любой справедливо подумал бы, что вы немного глупы. Но это сработает.

Оператор in

Python также предоставляет оператор членства, который можно использовать со строками. Оператор in возвращает True , если первый операнд содержится во втором, и False в противном случае:

Существует также оператор not in , который делает обратное:

Встроенные строковые функции

Как вы видели в уроке по основным типам данных в Python, Python предоставляет множество функций, встроенных в интерпретатор и всегда доступных. Вот некоторые из них, которые работают со строками:

Они более подробно рассматриваются ниже.

Возвращает целочисленное значение для данного символа.

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

Самая простая схема в обычном использовании называется ASCII એ . Он охватывает общие латинские символы, с которыми вы, вероятно, больше всего привыкли работать. Для этих символов ord(c) возвращает значение ASCII એ для символа c :

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

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

Пока вы остаетесь в области общих символов, существует небольшая практическая разница между ASCII и Unicode. Но функция ord() также возвращает числовые значения для символов Юникода:

Возвращает символьное значение для данного целого числа.

chr() делает обратное ord() . При заданном числовом значении n chr(n) возвращает строку, представляющую символ, соответствующий n :

chr() также обрабатывает символы Юникода:

С помощью функции len() вы можете проверить длину строки Python. len(s) возвращает количество символов в s :

str(obj)

Возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен в виде строки. str(obj) возвращает строковое представление объекта obj :

Индексация Строк

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

В Python строки-это упорядоченные последовательности символьных данных, и поэтому их можно индексировать таким образом. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках ( [] ).

Индексация строк в Python основана на нуле: первый символ в строке имеет индекс 0 , следующий-индекс 1 и так далее. Индекс последнего символа будет равен длине строки минус единица.
Например, схематическое представление индексов строки ‘ foobar ‘ будет выглядеть следующим образом:

Отдельные символы могут быть доступны по индексу следующим образом:

Попытка индексировать за пределами конца строки приводит к ошибке:

Строковые индексы также могут быть заданы отрицательными числами, и в этом случае индексация происходит от конца строки назад: -1 относится к последнему символу, -2 -к предпоследнему символу и т. д. Вот та же самая диаграмма, показывающая как положительные, так и отрицательные индексы в строке ‘ foobar ‘:

Вот несколько примеров негативной индексации:

Попытка индексирования с отрицательными числами за пределами начала строки приводит к ошибке:

Для любой непустой строки s , s[len(s)-1] и s[-1] оба возвращают последний символ. Нет никакого индекса, который имеет смысл для пустой строки.

Нарезка строк

Python также допускает форму синтаксиса индексирования, которая извлекает подстроки из строки, известную как нарезка строк. Если s является строкой, то выражение вида [m:n] возвращает часть s , начинающуюся с позиции m и вплоть до позиции n , но не включая ее:

Помните: строковые индексы основаны на нуле. Первый символ в строке имеет индекс 0. Это относится как к стандартному индексированию, так и к нарезке.

Опять же, второй индекс указывает первый символ, который не включен в результат—символ ‘ r ‘ ( s[5] ) в приведенном выше примере. Это может показаться немного неинтуитивным, но это приводит к такому результату, который имеет смысл: выражение s[m:n] вернет подстроку длиной n — m символов, в данном случае 5 — 2 = 3 .

Если вы опустите первый индекс, срез начнется в начале строки. Таким образом, s[:m] и s[0:m] эквивалентны:

Аналогично, если вы опустите второй индекс, как в s[n:] , срез простирается от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкому s[n:len(s)] :

Для любых строк и любого целого числа n (0 = n = len(s)) , s[:n] + s[n:] будет равно s :

Опущение обоих индексов возвращает исходную строку целиком. Буквально. Это не копия, а ссылка на исходную строку:

Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один запутанный способ сгенерировать пустую строку, если вы ее искали:

Отрицательные индексы также могут быть использованы при нарезке. -1 относится к последнему символу, -2 -к предпоследнему и так далее, как и в случае простого индексирования. На приведенной ниже диаграмме показано, как срезать подстроку » oob «из строки » foobar «, используя как положительные, так и отрицательные индексы:

Вот соответствующий код Python:

Указание шага в срезе строки

Существует еще один вариант синтаксиса нарезки, который следует обсудить. Добавление дополнительного : и третий индекс обозначает шаг, который указывает, сколько символов нужно перепрыгнуть после извлечения каждого символа в срезе.

Например, для строки ‘ foobar ‘ фрагмент 0:6:2 начинается с первого символа и заканчивается последним символом (целой строкой), а каждый второй символ пропускается. Это показано на следующей диаграмме:

Аналогично, 1:6:2 задает срез, начинающийся со второго символа (индекс 1) и заканчивающийся последним символом, и снова значение шага 2 вызывает пропуск всех остальных символов:

Иллюстративный REPL код показан здесь:

Как и при любом разрезании, первый и второй индексы могут быть опущены, а по умолчанию используются соответственно первый и последний символы:

Вы также можете указать отрицательное значение шага, и в этом случае Python делает шаг назад через строку. В этом случае начальный/первый индекс должен быть больше конечного/второго индекса:

В приведенном выше примере 5:0:-2 означает “начать с последнего символа и отступить назад на 2, вплоть до первого символа, но не включая его.”

Когда вы отступаете назад, если первый и второй индексы опущены, значения по умолчанию меняются интуитивно: первый индекс по умолчанию находится в конце строки, а второй индекс по умолчанию-в начале. Вот вам пример:

Это обычная парадигма для обращения строки вспять:

Интерполяция переменных в строку

В Python версии 3.6 был введен новый механизм форматирования строк. Эта функция формально называется форматированным строковым литералом, но чаще всего упоминается под псевдонимом f-string.

Одна простая функция вне строк, которую вы можете начать использовать сразу же,-это переменная интерполяция. Вы можете указать имя переменной непосредственно в литерале f-string, и Python заменит это имя соответствующим значением.

Например, предположим, что вы хотите отобразить результат арифметического вычисления. Это можно сделать с помощью простого оператора print() , разделяющего числовые значения и строковые литералы запятыми:

Но это слишком громоздко. Чтобы сделать то же самое, используйте f-строку:

• Укажите либо нижний регистр f либо верхний регистр F непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка вместо стандартной строки.
• Укажите любые переменные, которые будут интерполированы в фигурных скобках ( <> ).

Переделанный с помощью f-строки, приведенный выше пример выглядит гораздо чище:

Любой из трех механизмов цитирования Python может быть использован для определения f-строки:

Изменение Строк

Короче говоря, вы не можете. Строки-это один из типов данных, которые Python считает неизменяемыми, то есть не подлежащими изменению. Фактически, все типы данных, которые вы видели до сих пор, неизменны. (Python предоставляет типы данных, которые являются изменяемыми, как вы скоро увидите.)

Подобное утверждение приведет к ошибке:

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

Для этого также существует встроенный строковый метод:

Читайте дальше для получения дополнительной информации о встроенных строковых методах!

Встроенные строковые методы

В уроке по переменным в Python вы узнали, что Python-это высоко объектно-ориентированный язык. Каждый элемент данных в программе Python является объектом.

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

Методы подобны функциям. Метод — это специализированный тип вызываемой процедуры, тесно связанный с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается для конкретного объекта и имеет знание о своем целевом объекте во время выполнения.

Синтаксис вызова метода для объекта выглядит следующим образом:

Это вызывает метод .foo() на объекте obj.<args> указывает аргументы, передаваемые методу (если таковые имеются).

Вы узнаете гораздо больше об определении и вызове методов позже в обсуждении объектно-ориентированного программирования. На данный момент цель состоит в том, чтобы представить некоторые из наиболее часто используемых встроенных методов, поддерживаемых Python для работы со строковыми объектами.

В следующих определениях методов аргументы, указанные в квадратных скобках ( [] ), являются необязательными.

Преобразования Регистра

Методы этой группы выполняют преобразование регистра в целевой строке.

s.capitalize()

Возвращает целевую строку с заглавной первой буквой.

s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и всеми остальными символами, преобразованными в нижний регистр:

Неалфавитные символы остаются неизменными:

s.lower()

Преобразует буквенные символы в строчные.

s.lower() возвращает копию s со всеми заглавными символами, преобразованными в нижний регистр:

s.swapcase()

Меняет местами регистр буквенных символов.

s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:

s.title()

Преобразует целевую строку в » регистр заголовка.”

s.title() возвращает копию s , в которой первая буква каждого слова преобразуется в верхний регистр, а остальные буквы-в нижний:

Этот метод использует довольно простой алгоритм. Он не пытается провести различие между важными и неважными словами, и он не обрабатывает апострофы, притяжательные или аббревиатуры изящно:

s.upper()

Преобразует буквенные символы в заглавные.

s.upper() возвращает копию s со всеми буквенными символами, преобразованными в верхний регистр:

Найти и заменить

Эти методы предоставляют различные средства поиска целевой строки для указанной подстроки.

Каждый метод в этой группе поддерживает необязательные аргументы <start> и <end> . Они используются для нарезки строк: действие метода ограничено частью целевой строки, начинающейся с позиции символа <start> и продолжающейся до позиции символа <end> , но не включающей ее. Если < start> указан, а <end> нет, то метод применяется к части целевой строки от <start> до конца строки.

s.count(<sub>[, <start>[, <end>]])

Подсчитывает вхождения подстроки в целевую строку.

s.count(<sub>) возвращает количество неперекрывающихся вхождений подстроки <sub> в s :

Подсчет ограничен количеством вхождений в подстроку, обозначенную <start> и <end> , если они указаны:

s.endswith(<suffix>[, <start>[, <end>]])

Определяет, заканчивается ли целевая строка заданной подстрокой.

s.endswith(<suffix>) возвращает True , если s заканчивается указанным <suffix> , и False в противном случае:

Сравнение ограничивается подстрокой, обозначенной <start> и <end> , если они указаны:

s.find(<sub>[, <start>[, <end>]])

Выполняет поиск в целевой строке заданной подстроки.

Вы можете использовать .find() , чтобы увидеть, содержит ли строка определенную подстроку. s.find(<sub>) возвращает самый низкий индекс в s , где находится подстрока <sub> :

Этот метод возвращает -1 , если указанная подстрока не найдена:

Поиск ограничен подстрокой, указанной <start> и <end> , если они указаны:

s.index(<sub>[, <start>[, <end>]])

Выполняет поиск в целевой строке заданной подстроки.

Этот метод идентичен методу .find() , за исключением того, что он вызывает ошибку, если <sub> не найден, а не возвращает -1 :

s.rfind(<sub>[, <start>[, <end>]])

Поиск в целевой строке заданной подстроки, начинающейся в конце.

s.rfind(<sub>) возвращает самый высокий индекс в s , где найдена подстрока <sub> :

Как и в случае с .find() , если подстрока не найдена, возвращается -1 :

Поиск ограничен подстрокой, указанной <start> и <end> , если они указаны:

s.rindex(<sub>[, <start>[, <end>]])

Поиск в целевой строке заданной подстроки, начинающейся в конце.

Этот метод идентичен методу .rfind() , за исключением того, что он вызывает ошибку, если <sub> не найден, а не возвращает -1 :

s.startswith(<prefix>[, <start>[, <end>]])

Определяет, начинается ли целевая строка с заданной подстроки.

При использовании метода .startswith() s.startswith(<suffix>) возвращает True , если s начинается с указанного <suffix> , и False в противном случае:

Сравнение ограничивается подстрокой, обозначенной <start> и <end> , если они указаны:

Классификация Символов

Методы этой группы классифицируют строку на основе содержащихся в ней символов.

s.isalnum()

Определяет, состоит ли целевая строка из буквенно-цифровых символов.

s.isalnum() возвращает True , если s непусто и все его символы являются буквенно-цифровыми(либо буквой, либо цифрой), и False в противном случае:

s.isalpha()

Определяет, состоит ли целевая строка из буквенных символов.

s.isalpha() возвращает True , если s непусто и все его символы алфавитны, и False в противном случае:

s.isdigit()

Определяет, состоит ли целевая строка из цифровых символов.

Вы можете использовать метод .isdigit() , чтобы проверить, состоит ли ваша строка только из цифр. s.isdigit() возвращает True , если s непусто и все его символы являются числовыми цифрами, и False в противном случае:

s.isidentifier()

Определяет, является ли целевая строка допустимым идентификатором Python.

s.isidentifier() возвращает True , если s является допустимым идентификатором Python в соответствии с определением языка, и False в противном случае:

Примечание: .isidentifier() вернет True для строки, которая соответствует ключевому слову Python, даже если это на самом деле не является допустимым идентификатором:

Вы можете проверить, соответствует ли строка ключевому слову Python, используя функцию iskeyword() , которая содержится в модуле keyword . Один из возможных способов сделать это показан ниже:

Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вы должны проверить, что .isidentifier() является истинным, а iskeyword() — ложным.

s.islower()

Определяет, являются ли буквенные символы целевой строки строчными.

s.islower() возвращает True , если s непусто и все содержащиеся в нем буквенные символы строчные, и False в противном случае. Неалфавитные символы игнорируются:

s.isprintable()

Определяет, состоит ли целевая строка полностью из печатаемых символов.

s.isprintable() возвращает True , если s пуст или все содержащиеся в нем буквенные символы доступны для печати. Он возвращает False , если s содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

Примечание: Только метод .isxxxx() возвращает True , если s является пустой строкой. Все остальные возвращают False для пустой строки.

s.isspace()

Определяет, состоит ли целевая строка из пробельных символов.

s.isspace() возвращает True , если s непусто и все символы являются пробелами, и False в противном случае.

Наиболее часто встречающимися пробелами являются пробел ‘ ‘, табуляция ‘ \t ‘ и новая строка ‘ \n ‘:

Однако есть несколько других символов ASCII, которые квалифицируются как пробелы, и если вы учитываете символы Unicode, то их довольно много:

s.istitle()

Определяет, является ли целевая строка заголовком.

s.istitle() возвращает True , если s непусто, первый буквенный символ каждого слова прописной, а все остальные буквенные символы в каждом слове строчные. В противном случае он возвращает False :

Примечание: вот как документация Python описывает .istitle() , если вы находите это более интуитивно понятным: “заглавные символы могут следовать только за несокращенными символами, а строчные-только за прописными.”

s.isupper()

Определяет, являются ли буквенные символы целевой строки заглавными.

s.isupper() возвращает True , если s непусто и все содержащиеся в нем буквенные символы заглавные, и False в противном случае. Неалфавитные символы игнорируются:

Форматирование Строк

Методы этой группы изменяют или улучшают формат строки.

s.center(<width>[, <fill>])

s.center(<width>) возвращает строку, состоящую из s , центрированных в поле width <width&gt ;. По умолчанию заполнение состоит из символа пробела ASCII:

Если указан необязательный аргумент <fill> , то он используется в качестве символа заполнения:

Если аргумент уже имеет длину не менее <width> , то он возвращается без изменений:

s.expandtabs(tabsize=8)

Разворачивает столбцы в строку.

s.expandtabs() заменяет каждый символ табуляции (‘ \t ‘) пробелами. По умолчанию пробелы заполняются при условии остановки табуляции в каждом восьмом столбце:

tabsize является необязательным параметром, определяющим остановку колонны:

s.ljust(<width>[, <fill>])

Левостороннее выравнивание строки в поле.

s.ljust(<width>) возвращает строку, состоящую из s , выровненных по левому краю в поле ширина <width> . По умолчанию заполнение состоит из символа пробела ASCII:

Если указан необязательный аргумент <fill> , то он используется в качестве символа заполнения:

Если s уже достигает ширины такой как <width> , то он возвращается без изменений:

s.lstrip([<chars>])

Обрезает ведущие символы из строки.

s.lstrip() возвращает копию s с любыми пробелами, удаленными с левого конца:

Если указан необязательный аргумент <chars> , то это строка, указывающая набор удаляемых символов:

s.replace(<old>, <new>[, <count>])

Заменяет вхождения подстроки в строке.

В Python для удаления символа из строки можно использовать метод string.replace() . Метод s.replace(<old>, <new>) возвращает копию s со всеми вхождениями подстроки <old> , замененной на <new> .:

Если указан необязательный аргумент <count> , то выполняется максимум замен <count> , начиная с левого конца s :

s.rjust(<width>[, <fill>])

Правостороннее выравнивание строки в поле.

s.rjust(<width>) возвращает строку, состоящую из s , выровненных по правому краю в поле ширины <width> . По умолчанию заполнение состоит из символа пробела ASCII:

Если указан необязательный аргумент <fill> , то он используется в качестве символа заполнения:

Если s уже по крайней мере равен <width> , то он возвращается без изменений:

s.rstrip([<chars>])

Обрезает конечные символы из строки.

s.rstrip() возвращает копию s с любыми пробелами, удаленными с правого конца:

Если указан необязательный аргумент <chars> , то это строка, указывающая набор удаляемых символов:

s.strip([<chars>])

Удаляет символы с левого и правого концов строки.

s.strip() по существу эквивалентен вызову s.lstrip() и s.rstrip() последовательно. Без аргумента <chars> он удаляет начальные и конечные пробелы:

Как и в случае с .lstrip() и .rstrip() , необязательный аргумент <chars> указывает набор удаляемых символов:

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

s.zfill(<width>)

Подкладывает строку слева нулями.

s.zfill(<width>) возвращает копию s , заполненную слева символами ‘ 0 ‘ до указанной <width> :

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

Если s уже по крайней мере равен <width> , то он возвращается без изменений:

.zfill() наиболее полезен для строковых представлений чисел, но Python все равно будет обнулять строку, которая не является таковой.:

Преобразование между строками и списками

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

Многие из этих методов возвращают либо список, либо кортеж. Это составные типы данных, которые являются прототипическими примерами итерируемые объекты в Python. Они описаны в следующем уроке, так что вы скоро узнаете о них! До тех пор просто думайте о них как о последовательностях значений. Список заключен в квадратные скобки ( [] ), а кортеж-в круглые скобки ( () ).

С этим введением давайте взглянем на эту последнюю группу строковых методов.

s.join(<iterable>)

Конкатенация строк из итерируемого объекта.

s.join(<iterable>) возвращает строку, полученную в результате объединения объектов в <iterable> , разделенных s .

Обратите внимание, что .join() вызывается на s , строке-разделителе. <iterable> также должна быть последовательностью строковых объектов.

Некоторые примеры кода должны помочь прояснить ситуацию. В следующем примере разделителями являются строки ‘ , ‘, а <iterable> — список строковых значений:

В результате получается одна строка, состоящая из объектов списка, разделенных запятыми.

В следующем примере <iterable> задается как одно строковое значение. Когда строковое значение используется в качестве итеративного, оно интерпретируется как список отдельных символов строки:

Таким образом, в результате ‘ : ‘ .join(‘corge’) получается строка, состоящая из каждого символа в ‘ corge ‘, разделенного ‘ : ‘.

Этот пример терпит неудачу, потому что один из объектов в <iterable> не является строкой:

Это можно исправить с помощью:

Скоро увидите, многие составные объекты в Python могут быть истолкованы как итеративные, и .join() особенно полезен для создания строк из них.

s.partition(<sep>)

Делит строку на основе разделителя.

s.partition(<sep>) разбивает s при первом вхождении строки <sep> . Возвращаемое значение представляет собой кортеж из трех частей, состоящий из:

• Часть s , предшествующая <sep>
• Сам <sep>
• Часть s , следующая за <sep>

Вот несколько примеров .partition() в действии:

Если <sep> не найден в s , возвращаемый кортеж содержит s , за которым следуют две пустые строки:

s.rpartition(<sep>)

Делит строку на основе разделителя.

s.rpartition(<sep>) функционирует точно так же, как s.partition(<sep>) , за исключением того, что s разделяется при последнем вхождении <sep> вместо первого вхождения:

s.rsplit(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

Без аргументов s.split() разбивает s на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:

Если указан <sep> , то он используется в качестве разделителя для разделения:

(Если <sep> задано со значением None , строка разделяется пробелом, как если бы <sep> вообще не было задано.)

Когда <sep> явно задан в качестве разделителя, предполагается, что последовательные разделители в s разделяют пустые строки, которые будут возвращены:

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

Если указан необязательный параметр ключевого слова <maxsplit> , то выполняется максимум такое количество разбиений, начиная с правого конца s :

Значение по умолчанию для <maxsplit> равно -1 , что означает, что должны быть выполнены все возможные разбиения— так же, как если бы <maxsplit> был полностью опущен:

s.split(sep=None, maxsplit=-1)

Разбивает строку на список подстрок.

s.split() ведет себя точно так же, как s.rsplit() , за исключением того, что если задано <maxsplit> , то разбиения отсчитываются с левого конца s , а не с правого:

Если <maxsplit> не указан, то .split() и .rsplit() неразличимы.

s.splitlines([<keepends>])

Разрывает строку на границах линий.

s.splitlines() разбивает s на строки и возвращает их в виде спика. Любой из следующих символов или последовательностей символов считается границей линии:

Вот пример использования нескольких различных разделителей строк:

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

Если необязательный аргумент <keepends> указан и является истинным, то границы строк сохраняются в результирующих строках:

Объекты bytes

Объект bytes является одним из основных встроенных типов для манипулирования двоичными данными. Объект bytes — это неизменяемая последовательность однобайтовых значений. Каждый элемент в объекте bytes представляет собой небольшое целое число в диапазоне от 0 до 255.

Определение литерала объекта bytes

Байтовый литерал определяется так же, как и строковый литерал с добавлением префикса ‘ b ‘ :

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

В байтовом литерале допускаются только символы ASCII. Любое символьное значение больше 127 должно быть указано с помощью соответствующей escape-последовательности:

Префикс ‘ r ‘ может использоваться в байтовом литерале для отключения обработки escape-последовательностей, как и в случае со строками:

Определение объекта bytes с помощью встроенной функции bytes()

Функция bytes() также создает объект bytes . Какой тип байтов возвращается объекту, зависит от аргумента(ов), переданного функции. Возможные формы приведены ниже.

bytes(<s>, <encoding>)

Создает объект bytes из строки.

bytes(<s>, <encoding>) преобразует строку <s> в объект bytes , используя str.encode() в соответствии с заданной <encoding> :

Техническое Примечание: В этой форме функции bytes() требуется аргумент <encoding> . «Кодирование» относится к способу перевода символов в целочисленные значения. Значение «utf 8″ указывает на формат преобразования Unicode UTF-8, который является кодировкой, способной обрабатывать все возможные символы Unicode. UTF-8 также можно указать, указав » UTF8 «, » utf-8 » или » UTF-8 » для <encoding> .

Дополнительные сведения см. В документации Unicode. До тех пор, пока вы имеете дело с обычными латинскими символами, UTF-8 будет хорошо служить вам.

bytes(<size>)

Создает объект bytes , состоящий из нулевых ( 0x00 ) байтов.

bytes(<size>) определяет объект bytes указанного <size> , который должен быть положительным целым числом. Результирующий объект bytes инициализируется нулевыми ( 0x00 ) байтами:

bytes(<iterable>)

Создает объект bytes из итерируемого объекта.

bytes(<iterable>) определяет объект bytes из последовательности целых чисел, сгенерированных <iterable> . <iterable> должен быть итегрируемым, который генерирует последовательность целых чисел n в диапазоне 0 ≤ n ≤ 255 :

Операции с байтовыми объектами

Как и строки, объекты bytes поддерживают общие операции последовательности:

• Операторы in и not in :
• Операторы конкатенации ( + ) и репликации ( * ) :
• Индексирование и нарезка:
• Встроенные функции:

Многие методы, определенные для строковых объектов, допустимы и для байтовых объектов:

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

Хотя определение и представление байтового объекта основано на тексте ASCII, на самом деле он ведет себя как неизменяемая последовательность небольших целых чисел в диапазоне от 0 до 255 включительно. Вот почему один элемент из объекта bytes отображается как целое число:

Однако срез отображается как байтовый объект, даже если он имеет длину всего в один байт:

Вы можете преобразовать объект bytes в список целых чисел с помощью встроенной функции list()

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

bytes.fromhex(<s>)

Возвращает объект bytes , построенный из строки шестнадцатеричных значений.

bytes.fromhex(<s>) возвращает объект bytes , полученный в результате преобразования каждой пары шестнадцатеричных цифр в <s> в соответствующее значение байта. Шестнадцатеричные пары цифр в <s> могут быть дополнительно разделены пробелами, которые игнорируются:

Примечание: этот метод является методом класса, а не методом объекта. Он привязан к классу bytes , а не к объекту bytes . В следующих уроках по объектно-ориентированному программированию вы гораздо глубже изучите различие между классами, объектами и соответствующими им методами. А пока просто обратите внимание, что этот метод вызывается в классе bytes , а не в объекте b .

Возвращает строку, содержащую шестнадцатеричное значение из объекта в байтах.

b.hex() возвращает результат преобразования байтов объекта b в строку шестнадцатеричных пар цифр. То есть он делает обратное .fromhex() :

Примечание: В отличие от .fromhex() , .hex() — это объектный метод, а не метод класса. Таким образом, он вызывается на объекте класса bytes , а не на самом классе.

Объекты bytearray

Python поддерживает другой тип двоичной последовательности, называемый bytearray . Объекты bytearray очень похожи на объекты bytes , несмотря на некоторые различия:

• В Python нет специального синтаксиса для определения литерала байтового массива, такого как префикс ‘ b ‘, который может использоваться для определения объекта bytes . Объект bytearray всегда создается с помощью встроенной функции bytearray() :
• Объекты bytearray изменчивы. Вы можете изменить содержимое объекта bytearray с помощью индексации и нарезки:

Объект bytearray также может быть построен непосредственно из объекта bytes :

Вывод

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

Эти типы являются первыми типами, которые вы рассмотрели, которые являются составными-построенными из набора меньших частей. Python предоставляет несколько составных встроенных типов. В следующем уроке вы познакомитесь с двумя наиболее часто используемыми: списками и кортежами.