Методы строк python 3: Методы строк | Python

Содержание

Python | Основные методы строк

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

Последнее обновление: 02.05.2017

Рассмотрим основные методы строк, которые мы можем применить в приложениях:

  • isalpha(): возвращает True, если строка состоит только из алфавитных символов

  • islower(): возвращает True, если строка состоит только из символов в нижнем регистре

  • isupper(): возвращает True, если все символы строки в верхнем регистре

  • isdigit(): возвращает True, если все символы строки — цифры

  • isnumeric(): возвращает True, если строка представляет собой число

  • startswith(str): возвращает True, если строка начинается с подстроки str

  • endswith(str): возвращает True, если строка заканчивается на подстроку str

  • lower(): переводит строку в нижний регистр

  • upper(): переводит строку в вехний регистр

  • title(): начальные символы всех слов в строке переводятся в верхний регистр

  • capitalize(): переводит в верхний регистр первую букву только самого первого слова строки

  • lstrip(): удаляет начальные пробелы из строки

  • rstrip(): удаляет конечные пробелы из строки

  • strip(): удаляет начальные и конечные пробелы из строки

  • ljust(width): если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width,
    а сама строка выравнивается по левому краю

  • rjust(width): если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width,
    а сама строка выравнивается по правому краю

  • center(width): если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы,
    чтобы дополнить значение width, а сама строка выравнивается по центру

  • find(str[, start [, end]): возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1

  • replace(old, new[, num]): заменяет в строке одну подстроку на другую

  • split([delimeter[, num]]): разбивает строку на подстроки в зависимости от разделителя

  • join(strs): объединяет строки в одну строку, вставляя между ними определенный разделитель

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


string = input("Введите число: ")
if string.isnumeric():
    number = int(string)
    print(number)

Проверка, начинается или оканчивается строка на определенную подстроку:


file_name = "hello.py"

starts_with_hello = file_name.startswith("hello")   # True
ends_with_exe = file_name.endswith("exe")           # False

Удаление пробелов в начале и в конце строки:


string = "   hello  world!  "
string = string.strip()
print(string)           # hello  world!

Дополнение строки пробелами и выравнивание:


print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

Консольный вывод:


iPhone 7:      52000
Huawei P10:      36000

Поиск в строке

Для поиска подстроки в строке в Python применяется метод find(), который возвращает индекс первого вхождения подстроки в строку и
имеет три формы:

  • find(str): поиск подстроки str ведется с начала строки до ее конца

  • find(str, start): параметр start задает начальный индекс, с которого будет производиться поиск

  • find(str, start, end): параметр end задает конечный индекс, до которого будет идти поиск

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


welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# поиск с 10-го индекса
index = welcome.find("wor",10)
print(index)       # 21

# поиск с 10 по 15 индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Замена в строке

Для замены в строке одной подстроки на другую применяется метод replace():

  • replace(old, new): заменяет подстроку old на new

  • replace(old, new, num): параметр num указывает, сколько вхождений подстроки old надо заменить на new


phone = "+1-234-567-89-10"

# замена дефисов на пробел
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# удаление дефисов
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# замена только первого дефиса
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

Разделение на подстроки

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов.
Данный метод имеет следующие формы:

  • split(): в качестве разделителя используется пробел

  • split(delimeter): в качестве разделителя используется delimeter

  • split(delimeter, num): параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется
    в список без разделения на подстроки


text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой"
# разделение по пробелам
splitted_text = text.split()
print(splitted_text)
print(splitted_text[6])     # дуб,

# разбиение по запятым
splitted_text = text.split(",")
print(splitted_text)
print(splitted_text[1])     # в два обхвата дуб

# разбиение по первым пяти пробелам
splitted_text = text.split(" ", 5)
print(splitted_text)        
print(splitted_text[5])     # обхвата дуб, с обломанными ветвями и с обломанной корой

Соединение строк

При рассмотрении простейших операций со строками было показано, как объединять строки с помощью операции сложения. Другую возможность для соединения
строк представляет метод join(): он объединяет список строк. Причем текущая строка, у которой вызывается данный метод, используется в качестве разделителя:


words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# разделитель - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# разделитель - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

Вместо списка в метод join можно передать простую строку, тогда разделитель будет вставляться между символами этой строки:


word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

Python 3 #8: методы строк

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

строка.имя_метода(аргументы)

Для примера,
предположим, у нас имеется такая, уже классическая строка:

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

String.upper()

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

Вот по такому
синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает
ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами
говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому
метод upper возвращает
новую строку с заглавными буквами, не меняя прежней.

Если бы нам
потребовалось изменить строку, на которую ссылается переменная string, то это можно
сделать так:

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

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

Так тоже можно
делать.

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

String.lower()

который,
наоборот, преобразует все буквы в строчные. Например:

возвращает
строку «hello world!». Соответственно, сама строка здесь остается прежней,
измененным является новый строковый объект, который и возвращает метод lower. По такому
принципу работают все методы при изменении строк. Следующий метод

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

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


  • start – индекс, с
    которого начинается поиск;

  • end – индекс,
    которым заканчивается поиск.

В самом простом
случае, мы можем для строки

определить число
повторений сочетаний «ra»:

получим значение
2 – именно столько данная подстрока встречается в нашей строке.

Теперь
предположим, что мы хотим начинать поиск с буквы k, имеющей индекс
4.

Тогда метод
следует записать со значением start=4:

и мы получим
значение 1. Далее, укажем третий аргумент – индекс, до которого будет
осуществляться поиск. Предположим, что мы хотим дойти до 10-го индекса и
записываем:

и получаем
значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь,
также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы
говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11:

то последнее
включение найдется.

Следующий метод

String.find(sub[,
start[, end]])

возвращает
индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также
как и в методе count. Например:

вернет 1,
т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим
теперь значение start=2:

и поиск начнется
уже со второго индекса. Получим значение 8 – индекс следующего вхождения
подстроки «br». Если мы
укажем подстроку, которой нет в нашей строке:

то метод find возвращает -1. Третий
аргумент end определяет
индекс до которого осуществляется поиск и работает также как и в методе count.

Метод find ищет первое
вхождение слева-направо. Если требуется делать поиск в обратном направлении:
справа-налево, то для этого используется метод

String.rfind(sub[,
start[, end]])

который во всем
остальном работает аналогично find. Например:

возвратит 8 –
первое вхождение справа.

Наконец, третий
метод, аналогичный find – это:

String.index(sub[,
start[, end]])

Он работает
абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в
строке String, то метод
приводит к ошибке:

тогда как find возвращает -1.
Спрашивается: зачем нужен такой ущербный метод index? В
действительности такие ошибки можно обрабатывать как исключения и это бывает
полезно для сохранения архитектуры программы: когда неожиданные ситуации
обрабатываются единым образом в блоке исключений. Но, обо всем этом речь пойдет
позже.

Следующий метод

String.replace(old,
new, count=-1)

Выполняет замену
подстрок old на строку new и возвращает
измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o:

на выходе
получим строку «obrokodobro». Или, так:

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

Третий
необязательный аргумент задает максимальное количество замен. Например:

Заменит только
первые две буквы a: «msg.replace(«a», ‘o’, 2)». При значении
-1 количество замен неограниченно.

Следующие методы
позволяют определить: из каких символов состоит наша строка. Например, метод

String.isalpha()

возвращает True, если строка
целиком состоит из букв и False в противном случае. Посмотрим как он
работает:

вернет True, т.к. наша
строка содержит только буквенные символы. А вот для такой строки:

мы получим False, т.к. имеется
символ пробела.

Похожий метод

String.isdigit()

возвращает True, если строка
целиком состоит из цифр и False в противном случае. Например:

т.к. имеется
символ точки, а вот так:

получим значение
True. Такая проверка
полезна, например, перед преобразованием строки в целое число:

dig = input("Введите число: ")
if(dig.isdigit()):
   dig = int(dig)
    print(dig)
else:
   print("Число введено неверно")

Следующий метод

String.rjust(width[, fillchar = ‘ ‘])

возвращает новую
строку с заданным числом символов width и при
необходимости слева добавляет символы fillchar:

Получаем строку
«  abc» с двумя
добавленными слева пробелами. А сама исходная строка как бы прижимается к
правому краю. Или, можно сделать так:

Получим строку «—abc». Причем вторым
аргументом можно писать только один символ. Если записать несколько, то
возникнет ошибка:

Если ширина width будет меньше
длины строки:

то ничего не
изменится. Аналогично работает метод

String.ljust(width[, fillchar = ‘ ‘])

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

Следующий метод

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

возвращает
коллекцию строк, на которые разбивается исходная строка String. Разбивка
осуществляется по указанному сепаратору sep. Например:

"Иванов Иван Иванович".split(" ")

Мы здесь
разбиваем строку по пробелам. Получаем коллекцию из ФИО. Тот же результат будет
и при вызове метода без аргументов, то есть, по умолчанию он разбивает строку
по пробелам:

"Иванов Иван Иванович".split()

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

digs = "1, 2,3, 4,5,6"
digs.replace(" ", "").split(",")

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

Обратный метод

String.join(список)

возвращает
строку из объединенных элементов списка, между которыми будет разделитель String. Например:

d = digs.replace(" ", "").split(",")
", ".join(d)

получаем строку
«1, 2, 3, 4, 5, 6». Или так, изначально была строка:

fio = "Иванов Иван Иванович"

и мы хотим здесь
вместо пробелов поставить запятые:

fio2 = ",".join(fio.split())

Теперь fio2 ссылается на
строку с запятыми «Иванов,Иван,Иванович».

Следующий метод

String.strip()

удаляет пробелы
и переносы строк в начале и конце строки. Например:

"   hello world         \n".strip()

возвращает
строку «hello world». Аналогичные
методы:

String.rtrip()
и String.ltrip()

удаляют пробелы
и переносы строк только справа и только слева.

Вот такие методы
строк существуют в Python. Для наглядности ниже они представлены
в таблице:


















Название

Описание

String.upper()

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

String.lower()

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

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

Определяет
число вхождений подстроки в строке

String.find(sub[, start[, end]])

Возвращает
индекс первого найденного вхождения

String.rfind(sub[,
start[, end]])

Возвращает
индекс первого найденного вхождения при поиске справа

String.index(sub[,
start[, end]])

Возвращает
индекс первого найденного вхождения

String.replace(old,
new, count=-1)

Заменяет
подстроку old на new

String.isalpha()

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

String.isdigit()

Определяет:
состоит ли строка целиком из цифр

String.rjust(width[,
fillchar = ‘ ‘])

Расширяет
строку, добавляя символы слева

String.ljust(width[,
fillchar = ‘ ‘])

Расширяет
строку, добавляя символы справа

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

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

String.join(список)

Объединяет
коллекцию в строку

String.strip()

Удаляет
пробелы и переносы строк справа и слева

String.rstrip()

Удаляет
пробелы и переносы строк справа

String.ltrip()

Удаляет
пробелы и переносы строк слева

Задания для самоподготовки

1. Написать
программу корректности ввода телефонного номера по шаблону:

x(xxx)xxxxxx

где x – любая цифра от
0 до 9. Данные представлены в виде строки.

2. Написать
программу изменения строки

«2+3+6.7 +
82 + 5.7 +1″

на строку, в
которой все «+» заменены на «-» и удалены все пробелы

3. Написать
программу вывода чисел 0; -100; 5.6; -3 в виде столбца:


	0
	-100
	5.6
	-3

в котором все
строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).

4. В строке «abrakadabra» найдите все
индексы подстроки «ra» и выведите их (индексы) в консоль.

Методы строк в Python

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

Вызов метода в Python

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


переменная.метод(аргументы)

Поиск подстроки в строке Python

Для поиска подстроки в строке в Python, есть четыре метода:

  • find()
  • rfind()
  • index()
  • rindex()

Метод find() ищет индекс подстроки в строке — возвращает номер позиции символа указанного в аргументах.


>>> s='Найти подстроку'
>>> s.find('и')
4

В случае нескольких символов идущих подряд, Python вернет позицию, с которой начинается полное совпадение.


>>> s.find('под')
6

При обращении к несуществующей подстроке, вернется значение -1.


>>> s.find('ю')
-1

Метод index() тоже ищет подстроку в строке по её индексу, но в случае поиска несуществующей подстроки в отличии от find(), возвращает ошибку ValueError.

Методы rfind() и rindex() ищут подстроку с конца строки — справа.


>>> s.rfind('т')
10

Замена символа в строке

Метод replace() заменяет одни символы на другие, где первым параметром передаем, что заменить. А во втором параметре указываем , на что заменить.


>>> s.replace('ти','**')
'Най** подстроку'

Как удалить символ из строки?

Передадим во втором параметре пустые кавычки.


>>> s.replace('п','')
'Найти одстроку'

Как удалить пробелы в строке?

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


>>> s.replace(' ','')
'Найтиподстроку'

Разделить строку в Python

По умолчанию метод split() разделяет строку по пробелам и преобразует строку в список. В итоге мы получили список из трех элементов.


>>> h='разбить строку питон'
>>> h.split()
['разбить', 'строку', 'питон']

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


# Пример 1 - разделить по тире "-"

>>> p='питон-1 питон-2'
>>> p.split('-')
['питон', '1 питон', '2']

# Пример 2 - разделить по букве "t"

>>> c='method split in python'
>>> c.split('t')
['me', 'hod spli', ' in py', 'hon']


Объединить строки в Python

Несмотря на то, что метод join() является не строковым методом. Мы все равно его изучим в рамках данного урока. Поскольку join() в Python выполняет противоположную функцию метода split(). Берет элементы списка и преобразует список в строку. Имя переменной, ссылающейся на список строк — единственный передаваемый параметр метода join(). Перед точкой, мы указали разделитель — пустые кавычки.


>>> a=['1', '2', '3', '4', '5']
>>> ''.join(a)
'12345'

# разделитель пробел
>>> ' '.join(a)
'1 2 3 4 5'

# разделитель запятая
>>> ','.join(a)
'1,2,3,4,5'

Метод join() не работает с числовыми данными. Следующая запись приведет к ошибке.


a=[6, 7, 8]
' '.join(a)

Перед использованием метода join(), следует числа привести к строкам.


>>> e=['9', '10']
>>> ' '.join(e)
'9 10'

Верхний регистр строки в Python

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


>>> w='верхний регистр'
>>> w.upper()
'ВЕРХНИЙ РЕГИСТР'

Нижний регистр строки в Python

Метод lower() приводит все буквы строки к нижнему регистру.


>>> r='НИЖНИЙ РЕГИСТР'
>>> r.lower()
'нижний регистр'

Подсчет количества символов

Метод count() считает, сколько раз встречается подстрока в строке, указанная в параметрах.


>>> y="посчитать количество слов"
>>> y.count('о')
3

Проверка символов в строке

Метод isalpha() проверяет, состоит ли строка только из букв и возвращает истину или ложь.


>>> i='толькобуквы'
>>> i.isalpha()
True

Метод isdigit() проверяет, состоит ли строка только из цифр и возвращает истину или ложь.


>>> f='23456hbbn'
>>> f.isdigit()
False

  • Создано 30.10.2019 10:53:26

  • Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Python: поиск подстроки, операции со строками. Как выполнять поиск в строке Python?

В этой статье поговорим про строки в Python, особенности поиска, а также о том, как искать подстроку или символ в строке. Но сначала давайте вспомним основные методы для обработки строк в Python:
• isalpha(str): если строка в Python включает в себя лишь алфавитные символы, возвращается True;
• islower(str): True возвращается, если строка включает лишь символы в нижнем регистре;
• isupper(str): True, если символы строки в Python находятся в верхнем регистре;
• startswith(str): True, когда строка начинается с подстроки str;
• isdigit(str): True, когда каждый символ строки — цифра;
• endswith(str): True, когда строка в Python заканчивается на подстроку str;
• upper(): строка переводится в верхний регистр;
• lower(): строка переводится в нижний регистр;
• title(): для перевода начальных символов всех слов в строке в верхний регистр;
• capitalize(): для перевода первой буквы самого первого слова строки в верхний регистр;
• lstrip(): из строки в Python удаляются начальные пробелы;
• rstrip(): из строки в Python удаляются конечные пробелы;
• strip(): из строки в Python удаляются и начальные, и конечные пробелы;
• rjust(width): когда длина строки меньше, чем параметр width, слева добавляются пробелы, строка выравнивается по правому краю;
• ljust(width): когда длина строки в Python меньше, чем параметр width, справа от неё добавляются пробелы для дополнения значения width, при этом происходит выравнивание строки по левому краю;
• find(str[, start [, end]): происходит возвращение индекса подстроки в строку в Python. В том случае, если подстрока не найдена, выполняется возвращение числа -1;
• center(width): когда длина строки в Python меньше, чем параметр width, слева и справа добавляются пробелы (равномерно) для дополнения значения width, причём происходит выравнивание строки по центру;
• split([delimeter[, num]]): строку в Python разбиваем на подстроки в зависимости от разделителя;
• replace(old, new[, num]): в строке одна подстрока меняется на другую;
• join(strs): строки объединяются в одну строку, между ними вставляется определённый разделитель.

Обрабатываем строку в Python

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

string = input("Введите какое-нибудь число: ")
if string.isnumeric():
    number = int(string)
    print(number)

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

string = "   привет мир!  "
string = string.strip()
print(string)           # привет мир!

Так можно дополнить строку пробелами и выполнить выравнивание:

print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

В консоли Python будет выведено следующее:

iPhone 7:      52000
Huawei P10:      36000

Поиск подстроки в строке

Чтобы в Python выполнить поиск в строке, используют метод find(). Он имеет три формы и возвращает индекс 1-го вхождения подстроки в строку:
• find(str): поиск подстроки str производится с начала строки и до её конца;
• find(str, start): с помощью параметра start задаётся начальный индекс, и именно с него и выполняется поиск;
• find(str, start, end): посредством параметра end задаётся конечный индекс, поиск выполняется до него.

Когда подстрока не найдена, метод возвращает -1:

    welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# ищем с десятого индекса
index = welcome.find("wor",10)
print(index)       # 21

# ищем с 10-го по 15-й индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Замена в строке

Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace():
• replace(old, new): подстрока old заменяется на new;
• replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.

Пример замены в строке в Python:

    phone = "+1-234-567-89-10"

# дефисы меняются на пробелы
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# дефисы удаляются
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# меняется только первый дефис
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

Разделение на подстроки в Python

Для разделения в Python используется метод split(). В зависимости от разделителя он разбивает строку на перечень подстрок. В роли разделителя в данном случае может быть любой символ либо последовательность символов. Этот метод имеет следующие формы:
• split(): в роли разделителя применяется такой символ, как пробел;
• split(delimeter): в роли разделителя применяется delimeter;
• split(delimeter, num): параметром num указывается, какое количество вхождений delimeter применяется для разделения. При этом оставшаяся часть строки добавляется в перечень без разделения на подстроки.

Соединение строк в Python

Рассматривая простейшие операции со строками, мы увидели, как объединяются строки через операцию сложения. Однако есть и другая возможность для соединения строк — метод join():, объединяющий списки строк. В качестве разделителя используется текущая строка, у которой вызывается этот метод:

words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# символ разделителя - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# символ разделителя - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

А если вместо списка в метод join передать простую строку, разделитель будет вставляться уже между символами:

word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

Python: str() — работа со строками — Школа N61 г.Ульяновска



S = 'str';

S = "str";

S = '''str''';

S = """str"""
Литералы строк
S = "s\np\ta\nbbb" Экранированные последовательности
S = r"C:\temp\new" Неформатированные строки (подавляют экранирование)
S = b"byte" Строка байтов
S1 + S2 Конкатенация (сложение строк)
S1 * 3 Повторение строки
S[i] Обращение по индексу
S[i:j:step] Извлечение среза
len(S) Длина строки
S.find(str[, start[, end]) Поиск подстроки в строке. Возвращает номер первого вхождения (индекс подстроки в строке) или -1
S.rfind(str[, start[, end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str[, start[, end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str[, start[, end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(old, new[, num]) Заменяет в строке S одну подстроку (old) на другую (new) num раз.

Если num не указано, то заменить все вхождения old на new.

Если num = 1, то заменить первое вхождение old на new.

Если num = 3 — заменить первые 3 вхождения old на new.
S.split([delimeter[, num]]) разбивает строку на подстроки в зависимости от разделителя
S.join(список) объединяет строки в одну строку, вставляя между ними определенный разделитель S
S.isdigit() возвращает True, если все символы строки — цифры
S.isnumeric() возвращает True, если строка представляет собой число
S.isalpha() возвращает True, если строка состоит только из алфавитных символов
S.isalnum() Состоит ли строка из цифр или букв
S.islower() возвращает True, если строка состоит только из символов в нижнем регистре. Знаки препинания и цифры дают True.
S.isupper() возвращает True, если все символы строки в верхнем регистре. Знаки препинания и цифры дают True.
S.isspace() Состоит ли строка из неотображаемых символов
(пробел,
символ перевода страницы (‘\f’),
«новая строка» (‘\n’),
«перевод каретки» (‘\r’),
«горизонтальная табуляция» (‘\t’) и
«вертикальная табуляция» (‘\v’))
S.istitle() Возвращает True, если ВСЕ слова в строке начинаются с заглавной буквы
S.startswith(str) Возвращает True, если строка начинается с подстроки str
S.endswith(str) Возвращает True, если строка заканчивается на подстроку str
S.capitalize() Переводит первый символ строки в верхний регистр,
а все остальные в нижний
S.upper() переводит строку в вехний регистр
S.lower() переводит строку в нижний регистр
S.title() начальные символы всех слов в строке переводятся в верхний регистр
ord(символ) Символ в его код ASCII
chr(число) Код ASCII в символ
S.center(width, [fill]) если длина строки меньше параметра width,
то слева и справа от строки равномерно добавляются пробелы,
чтобы дополнить значение width,
а сама строка выравнивается по центру
S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip([chars]) удаляет начальные пробелы из строки
S.rstrip([chars]) удаляет конечные пробелы из строки
S.strip([chars]) удаляет начальные и конечные пробелы из строки
(удаление пробельных символов в начале и в конце строки). В параметре chars можно перечислить символы в любом порядке, которые следует удалить — удаляется символ, который присутствует в chars.
S.partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.swapcase() Переводит символы нижнего регистра в верхний, а верхнего — в нижний
S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=" ") если длина строки меньше параметра width,
то справа от строки добавляются пробелы,
чтобы дополнить значение width,
а сама строка выравнивается по левому краю
S.rjust(width, fillchar=" ") если длина строки меньше параметра width,
то слева от строки добавляются пробелы,
чтобы дополнить значение width,
а сама строка выравнивается по правому краю
S.format(*args, **kwargs) Форматирование строки

Строковые методы | Кодкамп

Введение

Примеры

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

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

  • str.casefold
  • str.upper
  • str.lower
  • str.capitalize
  • str.title
  • str.swapcase

С юникод строк (по умолчанию в Python 3), эти операции не являются 1: 1 отображения или обратимым. Большинство из этих операций предназначены для отображения, а не нормализации.  str.casefold()

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

 "XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

 

Преобразования, которые происходят в рамках casefolding, определяются Консорциумом Unicode в файле CaseFolding.txt на их веб-сайте.  str.upper()

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

 "This is a 'string'.".upper()
# "THIS IS A 'STRING'."

 

str.lower()

str.lower делает обратное; он берет каждый символ в строке и преобразует его в строчный эквивалент:

 "This IS a 'string'.".lower()
# "this is a 'string'."

 

str.capitalize()

str.capitalize возвращает заглавную версию строки, то есть, он делает первый символ имеет верхний регистр , а остальные нижние:

 "this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

 

str.title()

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

 "this Is a 'String'".title()
# "This Is A 'String'"

 

str.swapcase()

str.swapcase возвращает новый объект строки , в которой все строчные символы поменяны местами в верхний регистр и все символы верхнего регистра в нижний:

 "this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

 

Использование в качестве str методов класса

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

 str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

 

Это особенно полезно при применении одного из этих методов для многих строк сразу, скажем, на map функции.

 map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

 

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

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

str.split принимает строку и возвращает список подстрок исходной строки. Поведение отличается в зависимости от того sep предусмотрен или опущен аргумент.

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

 >>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

 

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

 >>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

 

По умолчанию заключается в разделении на каждом появлении разделителя, однако maxsplit параметр ограничивает количество расщеплений , которые происходят. Значение по умолчанию -1 означает , что нет предела:

 >>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

 

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

str.rsplit ( «правый раскол») отличается от str.split ( «левый сплит») , когда maxsplit указано. Расщепление начинается в конце строки, а не в начале:

 >>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

 

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

Заменить все вхождения одной подстроки другой подстрокой

Пайтона str типа также есть метод для замены вхождений одной подстроки с другой подстроки в заданной строке. Для более сложных случаев можно использовать re.sub .  str.replace(old, new[, count]) :

str.replace принимает два аргумента , old и new , содержащий old подстроку , которая должна быть заменена на new подстроку. Необязательный аргумент count определяет число замен , чтобы быть:

Например, для того , чтобы заменить 'foo' с 'spam' в следующей строке, мы можем назвать str.replace с old = 'foo' и new = 'spam' :

 >>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

 

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

 >>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

 

если, конечно, мы не поставляем значение для count . В этом случае count вхождения собираются заменяются:

 >>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'



 

str.format и f-strings: форматировать значения в строку

Python обеспечивает интерполяцию строки и функциональность форматирования через str.format функции, введенной в версии 2.6 и F-строк , введенных в версии 3.6.

Даны следующие переменные:

 i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

 

Следующие утверждения все эквивалентны

 "10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"
 
 >>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)
 
 >>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

 

Для справки, Python также поддерживает классификаторы в стиле C для форматирования строк. Примеры , приведенные ниже, эквивалентны тем , которые выше, но str.format вариантов являются предпочтительными из — за преимущества в гибкости, последовательности обозначений и расширяемости:

 "%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

 

Скобки используются для интерполяции в str.format также может быть пронумерована для уменьшения дублирования при форматировании строк. Например, следующее эквивалентно:

 "I am from Australia. I love cupcakes from Australia!"
 
 >>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

 

В то время как официальная документация питона, как обычно, достаточно тщательно, pyformat.info имеет большой набор примеров с подробными объяснениями.

Кроме того, { и } символы могут быть экранированы с помощью двойных скобок:

 "{'a': 5, 'b': 6}"
 
 >>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

 

См Строка форматирования для получения дополнительной информации. str.format() был предложен в PEP 3101 и F-строк в PEP 498 .

Подсчет количества появлений подстроки в строке

Один метод доступен для подсчета количества вхождений подстроки в другой строки, str.count .  str.count(sub[, start[, end]])

str.count возвращает int , указывающее количество неперекрывающихся вхождений подстрок sub в другой строке. Необязательные аргументы start и end указывают на начало и конец , в котором поиск будет происходить. По умолчанию start = 0 и end = len(str) означает всю строку будет искать:

 >>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

 

Задавая различные значения для start , end , мы можем получить более локализованный поиск и сосчитать, например, если start равно 13 призыва к:

 >>> s.count("sea", start)
1

 

эквивалентно:

 >>> t = s[start:]
>>> t.count("sea")
1 

Проверьте начальный и конечный символы строки

Для того , чтобы проверить начало и окончание данной строки в Python, можно использовать методы str.startswith() и str.endswith() .  str.startswith(prefix[, start[, end]])

Как следует это имя, str.startswith используется для проверки , начинается ли заданная строка с заданными символами в prefix .

 >>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

 

Необязательные аргументы start и end указать начальную и конечную точки , из которых тестирование будет начать и закончить. В следующем примере, указав начальное значение 2 наша строка будет просматриваться с позиции 2 , а затем:

 >>> s.startswith("is", 2)
True

 

Это дает True , так как s[2] == 'i' и s[3] == 's' .

Вы можете также использовать tuple , чтобы проверить , если он начинается с какой — либо из набора строк

 >>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

 

str.endswith(prefix[, start[, end]])

str.endswith точно похож на str.startswith с той лишь разницей, что он ищет окончание символов и не начиная символов. Например, чтобы проверить, заканчивается ли строка полной остановкой, можно написать:

 >>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

 

как и с startswith более одного символа может использоваться как окончание последовательности:

 >>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

 

Вы можете также использовать tuple , чтобы проверить , если он заканчивается любой из набора строк

 >>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False 

Проверка того, из чего состоит строка

Пайтона str тип также имеет целый ряд методов , которые могут быть использованы для оценки содержимого строки. Это str.isalpha , str.isdigit , str.isalnum , str.isspace . Капитализация может быть проверена с str.isupper , str.islower и str.istitle .  str.isalpha

str.isalpha не принимает никаких аргументов и возвращает True , если все символы в данной строке являются буквенными, например:

 >>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

 

В краевой случае пустая строка вычисляет значение False при использовании "".isalpha() .  str.isupper , str.islower , str.istitle

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

str.isupper это метод , который возвращает True , если все символы в данной строке в верхнем регистре и False иначе.

 >>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

 

С другой стороны , str.islower это метод , который возвращает True , если все символы в данной строке в нижнем регистре и False иначе.

 >>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

 

str.istitle возвращает True , если данная строка названия обсаженное; то есть каждое слово начинается с заглавной буквы, за которой следуют строчные буквы.

 >>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

 

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal возвращает строка , является ли последовательность десятичных цифр, пригодная для представления десятичного числа.

str.isdigit включает в себя цифру не в форме , подходящей для представления десятичного числа, такие , как надстрочные цифры.

str.isnumeric включает в себя любые числовые значения, даже если не цифры, такие как значения вне диапазона 0-9.

             isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

 

Байтовые строки ( bytes в Python 3, str в Python 2), поддерживает только isdigit , который проверяет только основные ASCII цифр.

Как str.isalpha пустая строка вычисляет значение False .  str.isalnum

Это сочетание str.isalpha и str.isnumeric , в частности , он имеет значение True , если все символы в данной строке являются буквенноцифровыми, то есть они состоят из буквенных или цифровых символов:

 >>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

 

str.isspace

Возвращает True , если строка содержит только пробельные символы.

 >>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

 

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

 >>> "".isspace()
False

 

Чтобы покрыть этот случай нам нужен дополнительный тест

 >>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

 

Но самый короткий путь , чтобы проверить , если строка пуста или содержит только пробельные символы, чтобы использовать strip (без аргументов она удаляет все начальные и конечные пробельные символы)

 >>> not my_str.strip()
True


 

str.translate: перевод символов в строке

Python поддерживает translate метод на str типа , который позволяет указать таблицу преобразования (используется для замены), а также любые символы , которые должны быть удалены в процессе.

 str.translate(table[, deletechars]) 

параметр  Описание  table   Это таблица поиска, которая определяет отображение от одного символа к другому.  deletechars   Список символов, которые должны быть удалены из строки.

maketrans метод ( str.maketrans в Python 3 и string.maketrans в Python 2) позволяет создать таблицу перевода.

 >>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th4s 3s 1 str3ng!'

 

translate метод возвращает строку , которая является переведенной копией исходной строки.

Вы можете установить table аргумент None , если требуется только для удаления символов.

 >>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl' 

Удаление нежелательных начальных / конечных символов из строки

Три метода при условии , что предлагают возможность раздеться начальные и конечные символы из строки: str.strip , str.rstrip и str.lstrip . Все три метода имеют одинаковую подпись, и все три возвращают новый строковый объект с удаленными нежелательными символами.  str.strip([chars])

str.strip действует на заданной строки и удаляет (полоски) или каких — либо ведущих задних символов , содержащихся в аргументе chars ; если chars не входит в комплект или нет None , все пробельные символы удаляются по умолчанию. Например:

 >>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

 

Если chars поставляются, все символы , содержащиеся в нем, удаляются из строки, которая возвращается. Например:

 >>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

 

str.rstrip([chars]) и str.lstrip([chars])

Эти методы имеют ту же семантику и аргументы с str.strip() , их отличие заключается в том направлении , откуда они начинаются. str.rstrip() начинается с конца строки в то время как str.lstrip() расщепляется с начала строки.

Например, при использовании str.rstrip :

 >>> "     spacious string      ".rstrip()
'     spacious string'

 

В то время как, используя str.lstrip :

 >>> "     spacious string      ".rstrip()
'spacious string      ' 

Сравнение строк без учета регистра

Сравнение строки без учета регистра кажется чем-то тривиальным, но это не так. В этом разделе рассматриваются только строки Unicode (по умолчанию в Python 3). Обратите внимание, что Python 2 может иметь незначительные недостатки по сравнению с Python 3 — более поздняя обработка юникода гораздо более полная.

Первое, на что следует обратить внимание, это то, что преобразования с удалением регистра в юникоде не являются тривиальными. Существует текст , для которого text.lower() != text.upper().lower() , Например, "ß" :

 >>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

 

Но предположим, что вы хотели регистронезависмо сравнивать "BUSSE" и "Buße" . Черт возьми, вы , вероятно , также хотят , чтобы сравнить "BUSSE" и "BUẞE" равный — это новая форма капитала. Рекомендуемый способ заключается в использовании casefold :

 >>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str

     Return a version of S suitable for caseless comparisons.
"""
 

Не просто использовать lower . Если casefold не доступен, делая .upper().lower() помогает (но только немного).

Тогда вы должны рассмотреть акценты. Если визуализатор шрифт хорошо, вы , вероятно , думаете , "ê" == "ê" — но это не так :

 >>> "ê" == "ê"
False

 

Это потому что они на самом деле

 >>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

 

Самый простой способ справиться с этим unicodedata.normalize . Вы , вероятно , хотите использовать NFKD нормализации, но не стесняйтесь проверить документацию. Тогда один

 >>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

 

Чтобы закончить, здесь это выражается в функциях:

 import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right) 

Объединить список строк в одну строку

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

 >>> " ".join(["once","upon","a","time"])
"once upon a time"

 

В следующем примере строковые элементы разделяются тремя дефисами.

 >>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time" 

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

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

 >>> import string

 

string.ascii_letters :

Стечение ascii_lowercase и ascii_uppercase :

 >>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

 

string.ascii_lowercase :

Содержит все символы нижнего регистра ASCII:

 >>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

 

string.ascii_uppercase :

Содержит все символы ASCII в верхнем регистре:

 >>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

 

string.digits :

Содержит все десятичные цифры:

 >>> string.digits
'0123456789'

 

string.hexdigits :

Содержит все шестнадцатеричные символы:

 >>> string.hexdigits
'0123456789abcdefABCDEF'

 

string.octaldigits :

Содержит все восьмеричные символы:

 >>> string.octaldigits
'01234567'

 

string.punctuation :

Содержит все символы , которые считаются знаки препинания в C локали:

 >>> string._`{|}~ \t\n\r\x0b\x0c' 

Сторнирование строки

Строка может реверсировать с использованием встроенных в reversed() функции, которая принимает строку и возвращает итератор в обратном порядке.

 >>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

 

reversed() могут быть обернуты в вызове ''.join() , чтобы сделать строку из итератора.

 >>> ''.join(reversed('hello'))
'olleh'

 

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

 >>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'


 

Обоснуйте строки

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

Ниже приведен пример str.ljust и str.rjust :

 interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))
 

40 -> 2555 миль (4112 км.) 19 -> 63 миль. (102 км.) 5 -> 1381 миль. (2222 км.) 93 -> 189 миль. (305 км.)

ljust и rjust очень похожи. Оба имеют width параметр и необязательный fillchar параметр. Любая строка , создаваемая эти функции, по крайней мере до тех пор , как width параметр , который был передан в функцию. Если строка длиннее , чем width alread, она не усекается. fillchar аргумент, который по умолчанию используется символ пробела ' ' должен быть один символ, а не multicharacter строка.

ljust функция подушечки конца строки она называется на с fillchar до тех пор, пока width длиной символов. rjust функция подушечки начала строки в подобной манере. Таким образом, l и r в названиях этих функций относятся к стороне , что исходная строка, а не fillchar , расположена в выходной строке.

Преобразование между str или байтовыми данными и символами юникода

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

В Python 2 вам может потребоваться преобразовать данные str в символы Unicode. По умолчанию ( '' , "" и т.д.) является строкой ASCII, с любыми значениями за пределами диапазона ASCII отображается в виде уцелевших значений. Unicode строки u'' (или u"" и т.д.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

 

В Python 3 вам может потребоваться преобразовать массивы байтов (называемые «байтовым литералом») в строки символов Unicode. По умолчанию теперь строка Unicode, и байтовой строки литералов теперь должны быть введены как b'' , b"" , и т.д. Байт буквальным будет возвращать True в isinstance(some_val, byte) , предполагая some_val быть строка , которая может быть закодированы в байтах.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.


Строка содержит

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

 >>> "foo" in "foo.baz.bar"
True

 

Примечание: тестирование пустой строки всегда будет приводить True :

 >>> "" in "test"
True 

Синтаксис

Параметры

Примечания

Python 3 — Строки

Строки являются одними из самых популярных типов в Python. Мы можем создать их, просто заключив символы в кавычках. Python рассматривает одиночные кавычки так же, как и двойные кавычки. Создание строк так же просто, как и присвоение значения переменной. Например:

var1 = 'Привет мир!'
var2 = "программирование на Python"

 

Доступ к значениям в строках

Python не поддерживает тип символов; они рассматриваются как строки одной длины, таким образом, также считается подстроки.

Чтобы получить доступ к подстроке, используйте квадратные скобки вместе с индексом или индексами, чтобы получить вашу подстроку. Например:

#!/usr/bin/python3

var1 = 'Привет мир!'
var2 = "программирование на Python"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

 

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

var1[0]:  П
var2[1:5]:  ytho

Обновление строк

Вы можете «обновить» существующую строку c присваиванием переменной на другую строку. Новое значение может быть связано с его предыдущим значением или совершенно другой строкой. Например:

#!/usr/bin/python3

var1 = 'Привет мир!'

print ("Обновление строки :- ", var1[:6] + 'Python')

 

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

Обновление строки :-  Hello Python

Символ Escape

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

Символ escape интерпретируется: в одинарных кавычках, а также в двойных кавычках.

Представление Шестнадцатеричный символ Описание
\a 0x07 Звонок или оповещение
\b 0x08 Backspace
\cx Control-х
\C-x Control-х
\e 0x1b Escape
\f 0x0C Formfeed
\M- \C-x Meta-Control-x
\n 0x0a Новая линия
\nnn Восьмеричная запись, где п находится в диапазоне от 0,7
\r 0x0d Возврат каретки
\s 0x20 Пробел
\t 0x09 Табуляция
\v 0x0B Вертикальная табуляция
\x Символ х
\xnn Шестнадцатеричное, где n находится в диапазоне от 0,9, a.f, или A.F

Специальные строковые операторы

Предположим, переменная строка а, имеет «Hello» а переменная b равна «Python», тогда:

оператор Описание пример
+ Конкатенация – Добавляет значения по обе стороны от оператора A + B = HelloPython
* Повторение – Создает новые строки, объединяя нескольких копий одной и той же строки а * 2 = HelloHello
[] Кусочек – Выдает символ из данного индекса а [1] = е
[ : ] Диапазон среза – Дает символы из заданного диапазона а [1: 4] = ELL
in Возвращает истину, если символ существует в данной строке Н = 1
not in Возвращает истину, если символ не существует в данной строке М <> 1
r/R Raw String – Подавляет фактическое значение символов Escape. Синтаксис для необработанных строк точно такой же, как и для обычных строк, за исключением raw строки оператора, буква «r», которая предшествует кавычки. «R» может быть в нижнем регистре (r) или в верхнем регистре (R) и должна быть размещена непосредственно предшествующей первой кавычки. print r’\n’ печатает \n и print R’\n’печатает \n
% Формат – Выполняет форматирование строк См в следующем разделе

Оператор форматирования строки

Одна из самых привлекательных особенностей языка Python является оператор форматирования строк %. Этот оператор является уникальным для строк и блоков, имеющие функции из языка C printf(). Ниже приведен простой пример:

#!/usr/bin/python3

print ("Меня зовут %s и мой вес равен %d кг!" % ('AndreyEx', 71))

 

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

Меня зовут AndreyEx и мой вес равен 71 кг!

 

Вот полный набор списка символов, которые могут быть использованы вместе с %:

S.No. Формат символов и преобразование
1 %c символ
2 %s преобразование строки с помощью str() до форматирования
3 %i десятичное число
4 %d десятичное число
5 %u беззнаковое десятичное целое
6 %o восьмеричное целое
7 %x шестнадцатеричное число (прописные буквы)
8 %X шестнадцатеричное число (заглавные буквы)
9 %e экспоненциальное (с строчной «х»)
10 %E экспоненциальное (с «E» в верхнем регистре)
11 %f вещественное число с плавающей точкой
12 %g наименьшее из %f и %е
13 %G наименьшее из% F% и E

 

Другие поддерживаемые символы и функции перечислены в следующей таблице:

S.No. Символ и функциональность
1 *           аргумент определяет ширину или точность
2 –           выравнивание по левому краю
3 +          отобразить знак
4 <sp>  поставить пробел перед положительным числом
5 #         добавить восьмеричной ведущий ноль ( «0») или шестнадцатеричным ведущий «0x» или «0X», в зависимости от того, был использован «х» или «X».
6 0         заместить слева нулями (вместо пробелов)
7 «%%» оставляет вас с одним буквальным «%»
8 (var) соотнесение переменных (словарные аргументы)
9 m.n.  минимальная общая ширина и n число цифр, отображаемых после десятичной точки (если заявл.)

Тройные кавычки

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

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

#!/usr/bin/python3

para_str = """это длинная строка, которая состоит из
несколько строк и непечатаемых символов, таких как
TAB ( \t ) и они показывают тот путь, когда отображается.
Символы новой строки в строке, прямо как
в скобках [ \n ], или просто новую строку с
присваиванием переменной также будет отображаться.
"""
print (para_str)

 

Когда приведенный выше код выполнится, он произведет следующий результат. Обратите внимание, что каждый специальный символ был преобразован в печатный вид, вплоть до последней новой строки в конце строки между «вверх». и закрытие тройные кавычки. Также отметим, что новая строка происходит либо с явным возвратом каретки в конце строки либо escape кодом (\n):

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

 

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

#!/usr/bin/python3

print ('C:\\nowhere')

 

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

C:\nowhere

 

Теперь давайте используем строку. Мы укажем выражение следующим образом:

#!/usr/bin/python3

print (r'C:\\nowhere')

 

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

C:\\nowhere

 

Строки Юникода

В Python 3 все строки представлены в Unicode. В Python 2 хранятся в виде 8-битного ASCII, следовательно, требуется указать «u», чтобы сделать его Unicode. Больше нет необходимости в настоящее время.

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

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

S.No. Методы и описание
1 capitalize() – Прописная первая буква строки
2 center(width, fillchar) – Возвращает строку, заполненную с FillChar от исходной строки с центром в общем столбце width.
3 count(str, beg = 0,end = len(string)) – Считает, сколько раз str имеет вхождение в строке или в подстроках строки, начиная с индекса str и заканчивается индексом end.
4 decode(encoding = ‘UTF-8’,errors = ‘strict’) – Декодирует строку, используя кодек, зарегистрированный для кодирования. кодирования по умолчанию строки по умолчанию кодировке.
5 encode(encoding = ‘UTF-8’,errors = ‘strict’) – Возвращает закодированные строки версии строки; при ошибке, по умолчанию вызывает исключение ValueError, если ошибки не указываются с  ‘ignore’ or ‘replace’.
6 endswith(suffix, beg = 0, end = len(string)) – Определяет, является ли строка или подстроку строки (если начальный индекс нач и заканчивая концом индекса приведены) заканчивается суффиксом; возвращает истину, если так и ложь в противном случае.
7 expandtabs(tabsize = 8) – Расширяет вкладки в строке на несколько пробелов; по умолчанию 8 пространств на вкладке, если TabSize не предусмотрено.
8 find(str, beg = 0 end = len(string)) – Определить, встречается ли строка в строке или в подстроки строки, если начинается с индекса beg и заканчивается индексом end, индекс возвращается, если найден и -1 в противном случае.
9 index(str, beg = 0, end = len(string)) – То же действие, что find(), но вызывает исключение, если строка не найдена.
10 isalnum() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы являются алфавитно-цифровыми и ложью в противном случае.
11 isalpha() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы буквенные и ложь в противном случае.
12 isdigit() – Возвращает истину, если строка содержит только цифры и ложь в противном случае.
13 islower() – Возвращает истину, если строка имеет по крайней мере 1 символ в нижнем регистре и все символы в нижнем регистре и ложь в противном случае.
14 isnumeric() – Возвращает истину, если строка Юникода содержит только числовые символы и ложь в противном случае.
15 isspace() – Возвращает истину, если строка содержит только символы пробелов и ложь в противном случае.
16 istitle() – Возвращает истину, если строка имеет«titlecased» и ложь в противном случае.
17 isupper() – Возвращает истину, если строка имеет по крайней мере один символ в верхнем регистре или все символы в верхнем регистре и ложь в противном случае.
18 join(seq) – Слияния (Объединяет) строковых элементов в последовательности seq в строку со строкой разделителя.
19 len(string) – Возвращает длину строки
20 ljust(width[, fillchar]) – Возвращает space-padded строку в исходную строку с выравниванием влево на итоговую ширину столбцов.
21 lower() – Преобразует все прописные буквы в строке в нижний регистр.
22 lstrip() – Удаляет начальные пробелы в строке.
23 maketrans() – Возвращает таблицу перевода для использования в функции перевода.
24 max(str) – Возвращает максимальный алфавитный символ из строки str.
25 min(str) – Возвращает минимальный алфавитный символ из строки str.
26 replace(old, new [, max]) – Заменяет все вхождения old в строке на new или в большинстве случаев, если max задано.
27 rfind(str, beg = 0,end = len(string)) – То же, что find(), но поиск в обратном направлении в строке.
28 rindex( str, beg = 0, end = len(string)) – То же, что index(), но поиск в обратном направлении в строке.
29 rjust(width,[, fillchar]) – Возвращает space-padded строку из исходной строки, выравнивается по правому краю в количестве width столбцов.
30 rstrip() – Удаляет все конечные пробелы из строки.
31 split(str=””, num=string.count(str)) – Разделяет строку в соответствии с разделителем str (пробел, если не предусмотрено) и возвращает список из подстроке; разделяет на num подстроку, если дано.
32 splitlines( num=string.count(‘\n’)) – Разбивает строку на все (или числа) строки и возвращает список каждой строки с удаленными символами новой строки.
33 startswith(str, beg=0,end=len(string)) – Определяет, является ли строка или подстрока в строке (если начальный индекс нач и заканчивается указанием на конец) начинается с подстроки str; возвращает истину, если так и ложь в противном случае.
34 strip([chars]) – Выполняет как lstrip() и rstrip() в строке
35 swapcase() – Инверсия для всех букв в строке.
36 title() – Возвращает «titlecased» версию строки, то есть, все слова начинаются с верхним регистром, а остальное в нижнем регистре.
37 translate(table, deletechars=””) – Переводит строку согласно таблице перевода str(256 символов), убрав deletechars.
38 upper() – Преобразование строчных букв в строке в верхний регистр.
39 zfill (width) – Возвращает исходную строку добавленную слева с нулями с указанной шириной символов; предназначенный для чисел, zfill() сохраняет любой данный знак (менее один ноль).
40 isdecimal() – Возвращает истину, если строка содержит только десятичные знаки и ложь в противном случае.

 

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Python 3-х строковые методы

Метод Описание Примеры
капитализировать ()

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

Используйте title () , если вы хотите, чтобы первый символ всех слов был заглавным (т. Е. Регистр заголовка).

a = «пчелиный укус»
печать (a.capitalize ())

Результат

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

a = «BEE»
print (a.casefold ())

Результат

  пчела  
центр ( ширина [, fillchar ]) Возвращает строку с центром в строке длиной шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s)

a = «пчела»
b = a.center (12, «-«)
print (b)

Результат

  ---- пчела -----  
count ( sub [, start [, end ]])

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

Неперекрывающиеся вхождения означает, что Python не будет дублировать символы, которые уже были подсчитаны. Например, при использовании подстроки xxx вместо xxxx возвращается 1 .

a = «Шашлычный суп»
print (a.count («O»))
print (a.count («o»))
print (a.count («oo»))
печать (a.счет («ооо»))
print (a.count («Гомер»))
print (a.count («o», 4, 7))
print (a.count («o», 7))

Результат

  0
5
2
1
0
2
3  
кодировать (encoding = "utf-8", errors = "strict")

Возвращает закодированную версию строки как байтовый объект. Кодировка по умолчанию — utf-8 . ошибки могут быть заданы для установки другой схемы обработки ошибок.Возможное значение для ошибок :

  • strict (ошибки кодирования вызывают UnicodeError )
  • игнорировать
  • заменить
  • xmlcharrefreplace
  • обратная косая черта заменить
  • любое другое имя, зарегистрированное с помощью codecs.register_error ()

из base64 импортировать b64encode

a = «Банан»
печать (а)

a = b64encode (a.кодировать ())
print (a)

Результат

  банан
b'QmFuYW5h ' 
заканчивается на ( суффикс [, начало [, конец ]])

Возвращает Истина , если строка заканчивается указанным суффиксом, в противном случае возвращает Ложь . суффикс также может быть кортежем суффиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции.С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Банан»
print (a.endswith («a»))
print (a.endswith («нана»))
print (a.endswith («z»))
print (a.endswith («an», 1, 3))

Результат

  Верно
Правда
Ложь
Правда  
expandtabs (tabsize = 8)

Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.Позиции табуляции появляются для каждого символа табуляции (по умолчанию 8 , что дает позиции табуляции в столбцах 0, 8, 16 и т. Д.).

а = «1 \ t2 \ t3»
печать (а)
печать (a.expandtabs ())
печать (a.expandtabs (tabsize = 12))
print (a.expandtabs (tabsize = 2))

Результат

  1 2 3
1 2 3
1 2 3
1 2 3  
find ( sub [, start [, end ]])

Возвращает наименьший индекс в строке, где подстрока sub находится в пределах фрагмента s [начало: конец] .Необязательные аргументы начало и конец интерпретируются как в нотации среза. Возвращает -1 , если sub не найден.

Метод find () следует использовать только в том случае, если вам нужно знать позицию подстроки. Если вам не нужно знать его позицию (т.е. вам нужно только знать, существует ли подстрока в строке), используйте оператор in . См. Строковые операторы для примера в .

a = «Фитнес»
print (a.find («F»))
print (a.find («f»))
print (a.find («n»))
print (a.find («сущность»))
print (a.find («ess»))
print (a.find («z»))
print (a.find («Homer»))

Результат

  0
-1
3
3
4
-1
-1  
формат (* args , ** kwargs )

Выполняет операцию форматирования строки.Строка, для которой вызывается этот метод, может содержать буквальный текст или поля замены, разделенные фигурными скобками {} . Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя аргумента ключевого слова. Возвращает копию строки, в которой каждое поле замены заменяется строковым значением соответствующего аргумента.

# Пример 1
print («{} и {}».формат («Чай», «Кофе»))

# Пример 2
print («{1} и {0}». format («Чай», «Кофе»))

# Пример 3
print («{обед} и {ужин}». format (обед = «Горошек», ужин = «Фасоль»))

# Пример 4
print («{0}, {1}, {2}». format (* «123»))

# Пример 5
обед = {«food»: «Пицца», «drink»: «Вино»}
print («Обед: {еда}, {напиток}». format (** обед))

Результат

  Чай и кофе
Кофе и чай
Горох и фасоль
1, 2, 3
Обед: пицца, вино  
format_map ( отображение )

Аналогичен формату (** отображение) , за исключением того, что отображение используется напрямую и не копируется в словарь.Это полезно, если, например, отображение является подклассом dict.

# Пример 1
обед = {«Еда»: «Пицца», «Напиток»: «Вино»}
print («Обед: {Еда}, {Напиток}». format_map (Обед))

# Пример 2
класс по умолчанию (dict):
def __missing __ (я, ключ):
ключ возврата

обед = {«Еда»: «Пицца»}
print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

обед = {«Напиток»: «Вино»}
print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

Результат

  Обед: пицца, вино
Обед: пицца, напитки
Обед: еда, вино  
индекс ( sub [, начало [, конец ]])

Подобно find () (см. Выше), но вызывает ValueError , когда подстрока не найдена ( find () возвращает -1 , если подстрока не найдена).

a = «Фитнес»
print (a.index («F»))
print (a.index («n»))
print (a.index («сущность»))
print (a.index («ess»))
print (a.index («z»)) #Error

Результат

  0
3
3
4
ValueError: подстрока не найдена  
isalnum ()

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

Символ c считается буквенно-цифровым, если одно из следующих значений возвращает True :

  • c.isalpha ()
  • c.isdecimal ()
  • c.isdigit ()
  • c. Числовой ()

c = «Фитнес»
печать (c.isalnum ())

c = «123»
печать (c.isalnum ())

c = «1,23»
печать (c.isalnum ())

c = «$ *% !!!»
печать (c.isalnum ())

c = «0,34j»
print (c.isalnum ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь  
isalpha ()

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

Обратите внимание, что «алфавитными» в данном случае являются те символы, которые определены в базе данных символов Unicode как «Letter». Это персонажи, общее свойство категории которых может быть одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Это отличается от свойства «Alphabetic», определенного в стандарте Unicode.

c = «Фитнес»
печать (c.isalpha ())

c = «123»
печать (c.isalpha ())

c = «$ *% !!!»
print (c.isalpha ())

Результат

  Верно
Ложь
Ложь  
десятичное ()

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

Десятичные символы — это те, которые могут использоваться для образования чисел с основанием 10. Десятичные символы — это символы из общей категории Unicode «Nd».

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123»
печать (c.isdecimal ())

c = u «\ u00B2»
печать (c.isdecimal ())

c = «1,23»
печать (c.isdecimal ())

c = «u123»
печать (c.isdecimal ())

c = «Фитнес»
печать (c.isdecimal ())

c = «$ *% !!!»
print (c.isdecimal ())

Результат

  Верно
Ложь
Ложь
Ложь
Ложь
Ложь  
isdigit ()

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

Метод isdigit () часто используется при работе с различными символами Юникода, например с надстрочными индексами (например, 2 ).

Цифра — это символ, имеющий значение свойства Numeric_Type = Digit или Numeric_Type = Decimal .

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123»
печать (c.isdigit ())

c = u «\ u00B2»
печать (c.isdigit ())

c = «1,23»
печать (c.isdigit ())

c = «u123»
печать (c.isdigit ())

c = «Фитнес»
печать (c.isdigit ())

c = «$ *% !!!»
print (c.isdigit ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
isidentifier ()

Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, разделом «Идентификаторы» и ключевыми словами из документации Python.

Используйте keyword.iskeyword () для проверки зарезервированных идентификаторов, таких как def , для и class .

а = «123»
печать (a.isidentifier ())

a = «_user_123»
печать (a.isidentifier ())

a = «_user-123»
печать (a.isidentifier ())

a = «Гомер»
печать (a.isidentifier ())

a = «для»
print (a.isidentifier ())

Результат

  Ложь
Правда
Ложь
Правда
Правда  
нижний ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из следующих: «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

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

а = «»
печать (a.islower ())

а = «123»
печать (a.islower ())

a = «_user_123»
печать (a.islower ())

a = «Гомер»
печать (a.islower ())

a = «HOMER»
печать (a.islower ())

а = «гомер»
печать (a.islower ())

a = «HOMER»
a = a.casefold () # Принудительно использовать строчные буквы
print (a.islower ())

Результат

  Ложь
Ложь
Правда
Ложь
Ложь
Правда
Правда  
числовой ()

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

Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения Unicode. Цифровые символы — это символы со значением свойства Numeric_Type = Digit , Numeric_Type = Decimal или Numeric_Type = Numeric .

c = «123»
печать (c.isnumeric ())

c = u «\ u00B2»
печать (c.isnumeric ())

c = «1,23»
печать (c.isnumeric ())

c = «u123»
печать (c.isnumeric ())

c = «Фитнес»
печать (c.isnumeric ())

c = «$ *% !!!»
print (c.isnumeric ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
для печати ()

Возвращает Истина , если все символы в строке печатаются или строка пуста. В противном случае возвращает False .

Непечатаемые символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», за исключением пробела ASCII ( 0x20 ), который считается печатаемым.

Печатные символы в этом контексте — это те, которые не следует экранировать при вызове repr () для строки. Он не имеет отношения к обработке строк, записанных в sys.stdout или sys.stderr .

а = «»
печать (a.isprintable ())

а = «»
печать (a.isprintable ())

a = u «\ u00B2»
печать (a.isprintable ())

a = «Барт»
печать (a.isprintable ())

а = «\ т»
печать (a.isprintable ())

a = «\ r \ n»
печать (a.isprintable ())

a = «Барт \ r»
print (a.isprintable ())

Результат

  Верно
Правда
Правда
Правда
Ложь
Ложь
Ложь  
isspace ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «»
печать (a.isspace ())

а = «»
печать (a.isspace ())

a = «Барт»
печать (a.isspace ())

а = «\ т»
печать (a.isspace ())

a = «\ r \ n»
печать (a.isspace ())

a = «Барт \ r»
print (a.isspace ())

Результат

  Ложь
Правда
Ложь
Правда
Правда
Ложь  
название ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «»
печать (a.istitle ())

а = «»
печать (a.istitle ())

а = «т»
печать (a.istitle ())

а = «Т»
печать (a.istitle ())

a = «Чай»
печать (a.istitle ())

a = «Чай и кофе»
печать (a.istitle ())

a = «Чай и кофе»
печать (a.istitle ())

a = «1. Чай и кофе \ r»
print (a.istitle ())

Результат

  Ложь
Ложь
Ложь
Правда
Правда
Ложь
Правда
Правда  
верхний ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из следующих: «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

а = «»
печать (a.isupper ())

а = «123»
печать (a.isupper ())

a = «_USER_123»
печать (a.isupper ())

a = «Гомер»
печать (a.isupper ())

a = «HOMER»
печать (a.isupper ())

а = «гомер»
печать (a.isupper ())

a = «HOMER»
a = a.casefold () # Принудительно использовать строчные буквы
print (a.isupper ())

Результат

  Ложь
Ложь
Правда
Ложь
Правда
Ложь
Ложь  
соединение (итерация)

Возвращает строку, которая представляет собой конкатенацию строк в итеративном .Ошибка TypeError будет вызвана, если есть какие-либо нестроковые значения в итерируемом , включая байтовые объекты. Разделителем между элементами является строка, обеспечивающая этот метод.

а = «-»
print (a.join («123»))

a = «.»
print (a.join («США»))

a = «.»
print (a.join ((«Dr», «Who»)))

Результат

  1-2-3
СОЕДИНЕННЫЕ ШТАТЫ АМЕРИКИ
Доктор Кто  
ljust ( ширина [, fillchar ]) Возвращает строку, выровненную по левому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s)

a = «пчела»
b = a.ljust (12, «-«)
print (b)

Результат

  пчела ---------  
нижний ()

Возвращает копию строки, в которой все символы в регистре преобразованы в нижний регистр.

casefold () — это более агрессивный метод перевода строки в нижний регистр, и он подходит для сопоставления регистра.

a = «BEE»
print (a.lower ())

Результат

  пчела  
lstrip ([ chars ])

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

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

a = «Пчела»
print (a.lstrip (), «!»)

a = «—— Пчела ——»
print (a.lstrip («-«))

Результат

  Пчела!
Пчела -----  
maketrans ( x [, y [, z ]])

Это статический метод, который возвращает таблицу перевода, используемую для str.Переводчик () .

  • Если есть только один аргумент, это должен быть словарь, отображающий порядковые номера Unicode (целые числа) или символы (строки длины 1) в порядковые номера Unicode, строки (произвольной длины) или установить значение None . После этого символьные ключи будут преобразованы в порядковые.
  • Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом в той же позиции в y .
  • Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены с Нет в результате.

frm = «SecrtCod»
to = «12345678»
trans_table = str.maketrans (от, до)
secret_code = «Секретный код» .translate (trans_table)
print (secret_code)

Результат

  123425 6782  
перегородка ( сен )

Разбивает строку при первом появлении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Python-программа»

print (a.partition («-«))
print (a.partition («.»))

Результат

  ('Python', '-', 'программа')
('Программа Python', '', '')  
заменить ( старый , новый [, count ])

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

a = «Чайный пакетик. Чайная чашка. Чайные листья.»

print (a.replace («Чай», «Кофе»))
print (a.replace («Чай», «Кофе», 2))

Результат

  Кофейный пакетик. Кофейная чашка. Листья кофе.
Пакетик для кофе. Кофейная чашка. Чайные листья. 
rfind ( sub [, start [, end ]])

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

a = «Да, фитнес»

print (a.rfind («Y»))
print (a.rfind («e»))
print (a.rfind («s»))
print (a.rfind («сс»))
print (a.rfind («y»))
print (a.rfind («z»))
print (a.rfind («Homer»))

Результат

  0
8
10
9
-1
-1
-1  
rindex ( sub [, start [, end ]])

Подобно rfind () , но вызывает ValueError , если подстрока sub не найдена.

a = «Да, фитнес»

print (a.rindex («Y»))
print (a.rindex («e»))
print (a.rindex («s»))
print (a.rindex («сс»))
print (a.rindex («y»))
print (a.rindex («z»))
print (a.rindex («Homer»))

Результат

  0
8
10
9
ValueError: подстрока не найдена
ValueError: подстрока не найдена
ValueError: подстрока не найдена  
rjust ( ширина [, fillchar ]) Возвращает строку, выровненную по правому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s)

a = «пчела»
b = a.rjust (12, «-«)
print (b)

Результат

  --------- пчела  
r раздел ( sep )

Разбивает строку в последнем вхождении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки.

a = «Гомер-Джей-Симпсон»

print (a.rpartition («-«))
print (a.rpartition («.»))

Результат

  ('Гомер-Джей', '-', 'Симпсон')
('', '', 'Гомер-Джей-Симпсон')  
rsplit (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , выполняется не более maxsplit разбиений, крайних правых . Если sep не указано или установлено значение None , любая строка с пробелами является разделителем.

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

a = «Гомер Джей Симпсон»
печать (a.rsplit ())

a = «Гомер-Джей-Симпсон»
печать (a.rsplit (sep = «-«, maxsplit = 1))

Результат

  [«Гомер», «Джей», «Симпсон»]
[«Гомер-Джей», «Симпсон»]  
rstrip ([ chars ])

Вернуть копию строки с удаленными завершающими символами. Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

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

a = «Пчела»
print (a.rstrip (), «!»)

a = «—— Пчела ——»
print (a.rstrip («-«))

Результат

  Пчела!
----- Пчела  
разделить (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , будет выполнено не более maxsplit разбиений. Если maxsplit не указано или -1 , то количество разделений не ограничено.

Если задано sep , последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, '1`` 2'.split (', ') возвращает [' 1 ',' ', '2'] ).

Аргумент sep может состоять из нескольких символов (например, '1 <> 2 <> 3'.split ('<>') возвращает ['1', '2', '3'] ). Разделение пустой строки указанным разделителем возвращает [''] .

Если sep не указано или установлено значение None , применяется другой алгоритм разделения: последовательности последовательных пробелов рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или в конце, если строка имеет начальные или конечные пробелы. Следовательно, разделение пустой строки или строки, состоящей только из пробелов, с помощью разделителя None возвращает значение [] .

a = «Гомер Джей Симпсон»
печать (a.split ())

a = «Гомер-Джей-Симпсон»
print (a.split (sep = «-«, maxsplit = 1))

a = «Гомер, Барт,»
print (a.split («,»))

a = «Гомер ,, Барт»
print (a.split («,», maxsplit = 1))

a = «Гомер <> Барт <> Мардж»
print (a.split («<>«))

Результат

  [«Гомер», «Джей», «Симпсон»]
["Гомер", "Джей-Симпсон"]
['Гомер', '', 'Барт', '']
['Гомер', ', Барт']
[«Гомер», «Барт», «Мардж»]  
Splitlines ([keepends])

Возвращает список строк в строке с разрывом по границам строки.Разрывы строк не включаются в результирующий список, если не указан keepends и его значение — True .

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

Представительство Описание
\ п Перевод строки
\ r Возврат каретки
\ n \ r Возврат каретки + перевод строки
\ v или \ x0b Таблица строк
\ f или \ x0c Подача формы
\ x1c Разделитель файлов
\ x1d Групповой разделитель
\ x1e Разделитель записей
\ x85 Следующая строка (контрольный код C1)
\ u2028 Разделитель линий
\ u2029 Разделитель абзацев

a = «Чай \ n \ nи кофе \ rчашки \ r \ n»

печать (a.splitlines ())
print (a.splitlines (keepends = True))

Результат

  ["Чай", "", "и кофе", "чашки"]
['Чай \ n', '\ n', 'и кофе \ r', 'чашки \ r \ n']  
начинается с (префикс [, начало [, конец ]])

Возвращает True , если строка начинается с указанного префикса, в противном случае возвращает False .Префикс также может быть кортежем префиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции. С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Гомер»
print (a.startswith («H»))
print (a.startswith («h»))
print (a.startswith («Гомер»))
print (a.startswith («z»))
print (a.startswith («om», 1, 3))

Результат

  Верно
Ложь
Правда
Ложь
Правда  
полоса ([ chars ])

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

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

a = «Пчела»
print (a.strip (), «!»)

a = «—— Пчела ——»
print (a.strip («-«))

Результат

  Пчела!
Пчела  
свопкейс ()

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

Обратите внимание, что использование swapcase () дважды в строке не всегда возвращает ее к исходному состоянию. В некоторых случаях два разных символа нижнего регистра используют один символ верхнего регистра, и, следовательно, замена регистра может иметь непреднамеренный эффект. См. Этот вопрос / ответ о переполнении стека для примеров.

a = «Гомер Симпсон»
print (a.swapcase ())

Результат

  ГОМЕР СИМПСОН  
название ()

Возвращает версию строки в заглавном регистре.Регистр заголовка — это когда слова начинаются с символа верхнего регистра, а остальные символы — с нижнего регистра.

Используйте capitalize () , если вы хотите, чтобы первое слово было заглавным.

a = «чай и кофе»
print (a.title ())

a = «ЧАЙ И КОФЕ»
print (a.title ())

Результат

  Чай и кофе
Чай и кофе  
перевести ( таблица )

Возвращает копию строки, в которой каждый символ был сопоставлен с данной таблицей перевода.Таблица должна быть объектом, который реализует индексацию через __getitem __ () , обычно это отображение или последовательность.

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

frm = «SecrtCod»
to = «12345678»
trans_table = str.maketrans (от, до)
secret_code = «Секретный код» .translate (trans_table)
print (secret_code)

Результат

  123425 6782  
верх ()

Возвращает копию строки, в которой все символы в регистре преобразованы в верхний регистр.

a = «пчела»
print (a.upper ())

Результат

  пчела  
zfill ( ширина )

Возвращает копию строки, заполненную слева цифрами ASCII 0 , чтобы получилась строка длиной и шириной . Префикс ведущего знака ( + / - ) обрабатывается путем вставки заполнения после символа знака, а не перед ним.Исходная строка возвращается, если ширина меньше или равна лин (с) .

а = «36»
печать (a.zfill (5))

а = «-36»
печать (a.zfill (5))

а = «+36»
print (a.zfill (5))

Результат

  00036
-0036
+0036  

Python 3 Примечания: строковые методы 1

На этой странице: .startwith (), .endswith (), in, .count (), .upper (), .lower (), .capitalize (), .title (), .replace () и .strip (). Также: составное приложение, например .lower (). Count ().

Испытания для субстрингового капота

.startswith () проверяет наличие префикса. При вызове как x.startswith (y) он возвращает True, если строка x начинается со строки префикса y, в противном случае — False. Примеры:

>>> 'school'.startswith (' s ')
Правда
>>> 'школа'.начинается с ('scho')
Правда
>>> 'school'.startswith (' k ')
Ложь
 

С другой стороны, .endswith () проверяет суффикс-капюшон. При вызове как x.endswith (y) он возвращает True, если строка x заканчивается указанной строкой суффикса y, в противном случае — False. Примеры:

>>> 'school'.endswith (' ол ')
Правда
>>> 'школа'.заканчивается с ('l')
Правда
>>> 'school'.endswith (' ll ')
Ложь
 

А как насчет подстрок посередине? Что ж, строки не имеют назначенного метода, но здесь можно использовать универсальный оператор in. Поскольку in не является строковым МЕТОДОМ, он использует другой синтаксис y в x:

>>> 'оо' в 'школе'
Правда
>>> 'h' в 'школе'
Правда
>>> 'що' в 'школе'
Правда
>>> 'школа' в 'школе'
Правда
>>> 'к' в 'школе'
Ложь
>>> "ее" в "школе"
Ложь
 

Подстрока подсчета

.count () возвращает количество вхождений данной подстроки. Возвращаемое значение — целое число:

>>> 'бесцветные зеленые идеи яростно спят'. count ('s')
5
>>> 'бесцветные зеленые идеи яростно спят'. count ('ee')
2
 

Корпусные манипуляторы

.upper () — метод в верхнем регистре. Он возвращает новую строку, в которой каждый символ находится в верхнем регистре..lower () делает обратное: он возвращает новую строку, в которой каждый символ в нижнем регистре.

>>> 'Не вводить'. Верхняя ()
'НЕ ВХОДИТЬ'
>>> 'НЕ ВВОДИТЬ'. Ниже ()
'Не входить'
 

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

>>> 'бесцветные зеленые идеи'.капитализировать ()
'Бесцветные зеленые идеи'
>>> 'бесцветные зеленые идеи'.title ()
«Бесцветные зеленые идеи»
 

Преобразование строки

.replace () принимает два параметра. Когда вызывается как x.replace (y, z), возвращается новая строка, в которой все экземпляры y в x заменяются на z.

>>> mary = 'У Мэри был ягненок'
>>> мэри.replace ('a', 'xx')
'Mxxry hxxd xx little lxxmb'
 

.replace () можно использовать для удаления подстрок, указав пустую строку » в качестве второго параметра:

>>> chom = 'Бесцветные зеленые идеи яростно спят'
>>> chom.replace ('ее', '')
'Бесцветные идеи grn яростно лупят'
>>> chom.replace ('', '')
`` Бесцветный зелёный сон бешено спит ''
 

Иногда строки приходят с пробельными символами с обоих концов, и вам нужно их удалить..strip () — это метод, который нужно использовать:

>>> foo = '\ t привет, мир \ n \ n'
>>> print (foo)
  Привет, мир


>>> foo.strip ()
'Привет, мир'
>>> print (foo.strip ())
Привет, мир
 

Составное приложение

Когда строковый метод возвращает строковый тип, можно добавить другой строковый метод.Ниже метод .replace () вызывается несколько раз, чтобы удалить все «гласные» символы:

>>> chom = 'Бесцветные зеленые идеи яростно спят'
>>> chom.replace ('а', '')
'Бесцветные зеленые яды яростно спят' 

>>> chom.replace (‘a’, ») .replace (‘e’, ») .replace (‘i’, ») .replace (‘o’, ») .replace (‘u’ , »)

 'Clrlss grn ds slp frsly'
 

В приведенном ниже примере.count () используется на выходе .lower (). Первоначально было только два счета «sh», потому что «Sh» не совпадало. После того, как вся струна опущена, «sh» соответствует три раза.

>>> foo = 'Она продает ракушки на берегу моря'
>>> foo.count ('ш')
2
>>> foo.lower ()
'она продает ракушки на берегу моря'
>>> foo.lower (). count ('ш')
3
 

Здесь важен порядок между двумя методами.Ниже сначала применяется .count (), а затем .lower (). Это не работает, потому что .count () возвращает целое число, а .lower () не работает с целочисленным типом.

>>> print (foo)
Она продает ракушки на берегу моря
>>> foo.count ('ш'). нижний ()

Отслеживание (последний вызов последний):
  Файл "", строка 1, в
    foo.count ('ш'). нижний ()
AttributeError: объект int не имеет атрибута lower
 

Строковые методы Python: пошаговое руководство

Python имеет много методов, используемых исключительно для строк.Строковые методы Python включают upper () , lower () , capitalize () , title () и другие. Эти строковые методы полезны для манипулирования, редактирования и работы со строками.

Найди свой матч на тренировочном лагере