Покажем основные типы данных:

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

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

message = “Hello World!”
print(message) # Hello World!

name = ‘Tom’
print(name) # Tom

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

text = (“Laudate omnes gentes laudate “
“Magnificat in secula “)
print(text)

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

”’
Это комментарий
”’
text = ”’Laudate omnes gentes laudate
Magnificat in secula
Et anima mea laudate
Magnificat in secula
”’
print(text)

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

Escape-последовательности в Python

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

Управляющие последовательности в строке
Строка может содержать ряд специальных символов – управляющих последовательностей или escape-последовательности. Некоторые из них:

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

\’: позволяет добавить внутрь строки одинарную кавычку

\”: позволяет добавить внутрь строки двойную кавычку

\n: осуществляет переход на новую строку

\t: добавляет табуляцию (4 отступа)

Используем некоторые последовательностей:

text = “Message:\n\”Hello World\””
print(text)

Необработанная строка в Python

Необработанная строка в Python создается путем добавления к строковому литералу префикса «r» или «R». Необработанная строка Python рассматривает обратную косую черту (\), как буквальный символ.

Это полезно, когда мы хотим иметь строку, содержащую обратную косую черту, и не хотим, чтобы она рассматривалась как escape-символ.

Допустим, мы хотим создать строку Hi\nHello в python. Если мы попытаемся назначить его обычной строке, \n будет рассматриваться как новая строка.

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

path = “C:\python\name.txt”
print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы “\n”, которые будут интерпретированы как управляющая последовательность.

Так, мы получим следующий консольный вывод:

C:\python

ame.txt

Чтобы избежать подобной ситуации, перед строкой ставится символ r

path = r”C:\python\name.txt”
print(path)

r от слова raw, т.е r – это сырые строки (необработанные строки).

Нужны для того, чтобы слеш \ не вызывал экранирование символов.

Популярные примеры \n, \t. Если у вас в строке есть \, который нужен сам по себе, то его нужно дополнительно экранировать самим \.

Пример:

"C:\\Users\\Foo"

Для raw-строк текст станет более человеко-читаемый:

r"C:\Users\Foo"

Сырые строки (raw string) – строки, в которых обратный слеш (\) не модифицирует следующий за ним символ.

Пример:

>>> print('abc\n123')
abc
123

>>> print(len('abc\n123'))
7

И:

>>> print(r'abc\n123')
abc\n123

>>> print(len(r'abc\n123'))
8

f-строки в Python

Начиная с версии 3.6 в Python появился новый тип строк — f-строки, которые буквально означают «formatted string». Эти строки улучшают читаемость кода, а также работают быстрее чем другие способы форматирования. F-строки задаются с помощью литерала «f» перед кавычками.

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

Python позволяет встравивать в строку значения других переменных. Для этого внутри строки переменные размещаются в фигурных скобках {}, а перед всей строкой ставится символ f:

userName = “Tom”
userAge = 37
user = f”name: {userName} age: {userAge}”
print(user) # name: Tom age: 37

В данном случае на место {userName} будет вставляться значение переменной userName. Аналогично на вместо {userAge} будет вставляться значение переменной userAge.

>>> name = "Дмитрий"
>>> age = 25
>>> print(f"Меня зовут {name} Мне {age} лет.")
>>> Меня зовут Дмитрий. Мне 25 лет.

f-строки также поддерживают расширенное форматирование чисел:

>>> from math import pi
>>> print(f"Значение числа pi: {pi:.2f}")
>>> Значение числа pi: 3.14

С помощью f-строк можно форматировать дату без вызова метода strftime():

>>> from datetime import datetime as dt
>>> now = dt.now()
>>> print(f"Текущее время {now:%d.%m.%Y %H:%M}")
>>> Текущее время 24.02.2017 15:51

Они поддерживают базовые арифметические операции. Да, прямо в строках:

>>> x = 10
>>> y = 5
>>> print(f"{x} x {y} / 2 = {x * y / 2}")
>>> 10 x 5 / 2 = 25.0

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

>>> planets = ["Меркурий", "Венера", "Земля", "Марс"]
>>> print(f"Мы живим не планете {planets[2]}")
>>> Мы живим не планете Земля

А также к элементам словаря по ключу:

>>> planet = {"name": "Земля", "radius": 6378000}
>>> print(f"Планета {planet['name']}. Радиус {planet['radius']/1000} км.")
>>> Планета Земля. Радиус 6378.0 км. 

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

>>> digits = {0: 'ноль', 'one': 'один'}
>>> print(f"0 - {digits[0]}, 1 - {digits['one']}")
>>> 0 - ноль, 1 - один

Вы можете вызывать в f-строках методы объектов:

>>> name = "Дмитрий"
>>> print(f"Имя: {name.upper()}")
>>> Имя: ДМИТИРИЙ

А также вызывать функции:

>>> print(f"13 / 3 = {round(13/3)}")
>>> 13 / 3 = 4

f-строки очень гибкий и мощный инструмент для создания самых разнообразных шаблонов.

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

Индексация строк в Python начинается с нуля: первый символ в строке имеет индекс 0, следующий — индекс 1 и так далее.

Индексом последнего символа будет длина строки — 1.

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

string = “hello world”
c0 = string[0] # h
print(c0)
c6 = string[6] # w
print(c6)

c11 = string[11] # ошибка IndexError: string index out of range
print(c11)

Индексация начинается с нуля, поэтому первый символ строки будет иметь индекс 0. А если мы попытаемся обратиться к индексу, которого нет в строке, то мы получим исключение IndexError. Например, в случае выше длина строки 11 символов, поэтому ее символы будут иметь индексы от 0 до 10.

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

Так, индекс -1 будет представлять последний символ,

а -2 – предпоследний символ и так далее:

string = “hello world”
c1 = string[-1] # d
print(c1)
c5 = string[-5] # w
print(c5)

При работе с символами следует учитывать, что строка – это неизменяемый (immutable) тип, поэтому если мы попробуем изменить какой-то отдельный символ строки, то мы получим ошибку, как в следующем случае:

string = “hello world”
string[1] = “R”

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

Перебор строки
С помощью цикла for можно перебрать все символы строки:

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

Например,

for i in "String":
    print(i)

Выход:

S
t
r
i
n
g

В приведенном выше примере мы можем напрямую обращаться к каждому символу в строке с помощью итератора i.

string = “hello world”
for char in string:
print(char)

Получение подстроки

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

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

string[:end]: извлекается последовательность символов начиная с 0-го индекса по индекс end (не включая)

string[start:end]: извлекается последовательность символов начиная с индекса start по индекс end (не включая)

string[start:end:step]: извлекается последовательность символов начиная с индекса start по индекс end (не включая) через шаг step

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

string = “hello world”

#с 0 до 5 индекса

sub_string1 = string[:5]
print(sub_string1) # hello

#со 2 до 5 индекса

sub_string2 = string[2:5]
print(sub_string2) # llo

#с 2 по 9 индекса через один символ

sub_string3 = string[2:9:2]
print(sub_string3) # lowr

Объединение строк
Одной из самых распространенных операций со строками является их объединение или конкатенация. Для объединения строк применяется операция сложения:

name = “Tom”
surname = “Smith”
fullname = name + ” ” + surname
print(fullname) # Tom Smith

С объединением двух строк все просто, но что, если нам надо сложить строку и число? В этом случае необходимо привести число к строке с помощью функции str():

name = “Tom”
age = 33
info = “Name: ” + name + ” Age: ” + str(age)
print(info) # Name: Tom Age: 33

Повторение строки
Для повторения строки определенное количество раз применяется операция умножения:

print(“a” * 3) # aaa
print(“he” * 4) # hehehehe

Сравнение строк
Особо следует сказать о сравнении строк. При сравнении строк принимается во внимание символы и их регистр.

Так, цифровой символ условно меньше, чем любой алфавитный символ. Алфавитный символ в верхнем регистре условно меньше, чем алфавитные символы в нижнем регистре.

Например:

str1 = “1a”
str2 = “aa”
str3 = “Aa”
print(str1 > str2) # False, так как первый символ в str1 – цифра
print(str2 > str3) # True, так как первый символ в str2 – в нижнем регистре

Поэтому строка “1a” условно меньше, чем строка “aa”. Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, “1a” меньше, чем “2a”.

Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, “aa” меньше, чем “ba”, а “ba” меньше, чем “ca”.

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

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

Функция lower() приводит строку к нижнему регистру, а функция upper() – к верхнему.

str1 = “Tom”
str2 = “tom”
print(str1 == str2) # False – строки не равны

print(str1.lower() == str2.lower()) # True

Функции ord и len
Поскольку строка содержит символы Unicode, то с помощью функции ord() мы можем получить числовое значение для символа в кодировке Unicode:

print(ord(“A”)) # 65

Для получения длины строки можно использовать функцию len():

string = “hello world”
length = len(string)
print(length) # 11

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

Часто нам нужно найти символ в строке python. Для решения этой задачи разработчики используют метод find().

Он помогает найти индекс первого совпадения подстроки в строке. Если символ или подстрока не найдены, find возвращает -1.

Синтаксис

string.find(substring,start,end)

Метод find принимает три параметра:

• substring (символ/подстрока) — подстрока, которую нужно найти в данной строке.
• start (необязательный) — первый индекс, с которого нужно начинать поиск. По умолчанию значение равно 0.
• end (необязательный) — индекс, на котором нужно закончить поиск. По умолчанию равно длине строки.

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

Параметры, которые передаются в метод, — это подстрока, которую требуются найти, индекс начала и конца поиска. Значение по умолчанию для начала поиска — 0, а для конца — длина строки.

В этом примере используем метод со значениями по умолчанию.

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

>>> string = "Добро пожаловать!"
>>> print("Индекс первой буквы 'о':", string.find("о"))
Индекс первой буквы 'о': 1

Поиск не с начала строки с аргументом start

Можно искать подстроку, указав также начальное положение поиска.

В этом примере обозначим стартовое положение значением 8 и метод начнет искать с символа с индексом 8. Последним положением будет длина строки — таким образом метод выполнит поиска с индекса 8 до окончания строки.

>>> string = "Специалисты назвали плюсы и минусы Python"
>>> print("Индекс подстроки 'али' без учета первых 8 символов:", string.find("али", 8))
Индекс подстроки 'али' без учета первых 8 символов: 16

Поиск символа в подстроке со start и end

С помощью обоих аргументов (start и end) можно ограничить поиск и не проводить его по всей строке. Найдем индексы слова «пожаловать» и повторим поиск по букве «о».

>>> string = "Добро пожаловать!"
>>> start = string.find("п")
>>> end = string.find("ь") + 1
>>> print("Индекс первой буквы 'о' в подстроке:", string.find("о", start, end))
Индекс первой буквы 'о' в подстроке: 7

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

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

>>> string = "Добро пожаловать!"
>>> print("Есть буква 'г'?", string.find("г") != -1)
Есть буква 'г'? False
>>> print("Есть буква 'т'?", string.find("т") != -1)
Есть буква 'т'? True

Поиск последнего вхождения символа в строку

Функция rfind() напоминает find(), а единое отличие в том, что она возвращает максимальный индекс. В обоих случаях же вернется -1, если подстрока не была найдена.

В следующем примере есть строка «Добро пожаловать!». Попробуем найти в ней символ «о» с помощью методов find() и rfind().

>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string.find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом rfind:", string.rfind("о"))
Поиск 'о' методом rfind: 11

Вывод показывает, что find() возвращает индекс первого совпадения подстроки, а rfind() — последнего совпадения.

Второй способ поиска — index()

Метод index() помогает найти положение данной подстроки по аналогии с find(). Единственное отличие в том, что index() бросит исключение в том случае, если подстрока не будет найдена, а find() просто вернет -1.

Вот рабочий пример, показывающий разницу в поведении index() и find():

>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string.find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом index:", string.index("о"))
Поиск 'о' методом index: 1

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

>>> string = "Добро пожаловать"
>>> print("Поиск 'г' методом find:", string.find("г"))
Поиск 'г' методом find: 1
>>> print("Поиск 'г' методом index:", string.index("г"))
Traceback (most recent call last):
  File "pyshell#21", line 1, in module
    print("Поиск 'г' методом index:", string.index("г"))
ValueError: substring not found

В этом примере мы пытались найти подстроку «г». Ее там нет, поэтому find() возвращает -1, а index() бросает исключение.

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

Чтобы найти общее количество совпадений подстроки в строке можно использовать ту же функцию find(). Пройдемся циклом while по строке и будем задействовать параметр start из метода find().

Изначально переменная start будет равна -1, что бы прибавлять 1 у каждому новому поиску и начать с 0. Внутри цикла проверяем, присутствует ли подстрока в строке с помощью метода find.

Если вернувшееся значение не равно -1, то обновляем значением count.

Вот рабочий пример:

my_string = "Добро пожаловать"
start = -1
count = 0

while True:
    start = my_string.find("о", start+1)
    if start == -1:
        break
    count += 1

print("Количество вхождений символа в строку: ", count )

Количество вхождений символа в строку: 4

Выводы

• Метод find() помогает найти индекс первого совпадения подстроки в данной строке. Возвращает -1, если подстрока не была найдена.
• В метод передаются три параметра: подстрока, которую нужно найти, start со значением по умолчанию равным 0 и end со значением по умолчанию равным длине строки.
• Можно искать подстроку в данной строке, задав начальное положение, с которого следует начинать поиск.
• С помощью параметров start и end можно ограничить зону поиска, чтобы не выполнять его по всей строке.
• Функция rfind() повторяет возможности find(), но возвращает максимальный индекс (то есть, место последнего совпадения). В обоих случаях возвращается -1, если подстрока не была найдена.
• index() — еще одна функция, которая возвращает положение подстроки. Отличие лишь в том, что index() бросает исключение, если подстрока не была найдена, а find() возвращает -1.
• find() можно использовать в том числе и для поиска общего числа совпадений подстроки.

Индексы и срезы строк

На самом деле в Python строка представляются как упорядоченная коллекция символов. И ключевое слово здесь – «упорядоченная». Это значит, что у каждого символа в строке есть свой порядковый номер – индекс, по которому мы можем его получить. Например, когда мы создаем строку

msg = "Hello World!"

то формируется следующая коллекция:

Каждый символ имеет свой индекс, начиная с нулевого. Первый символ в Python всегда имеет нулевой индекс.

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

<строка>[<индекс>]

Например:

msg[0]
msg[6]

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

msg[12]

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

lastIndex = len(<строка>) – 1

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

msg[len(msg)-1]

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

msg[-1]

Видите? Это намного удобнее. То есть, у строк есть еще такие отрицательные индексы:

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

"abcd"[1]
"abcd"[-1]

Иногда это бывает удобно.

Срезы

Часто в программировании требуется выбрать не один какой-то символ, а сразу несколько. Для этого используются так называемые срезы. Их работу проще показать на конкретных примерах. Пусть у нас есть наша строка:

msg = "Hello World!"

и мы хотим выделить последнее слово «World!». Для этого в квадратных скобках указывается начальный индекс и через двоеточие – конечный. Если мы запишем все вот в таком виде:

msg[6:11]

то получим результат «World» без восклицательного знака. Дело в том, что последний индекс исключается из интервала, то есть, интервал определяется как

[6: 11)

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

msg[6:12]

Другой пример для выделения символов «llo»:

msg[2:5]

и так далее.

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

Например:

msg[:5]

выделяет слово «Hello», а вот так:

msg[6:]

получим «World!». Наконец, записав все в таком виде:

msg[:]

получим ту же самую строку, не копию! Это можно проверить так:

copy = msg[:]
print(id(copy), id(msg))

Увидим одно и то же значение id для обеих переменных, это означет, что они ссылаются на один и тот же объект.

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

msg[::2]

мы здесь ставим еще одно двоеточие и указываем шаг 2, то есть, идем через символ: «HloWrd».

Также это можно комбинировать с граничными значениями:

msg[:5:2]
msg[6::2]
msg[1:6:2]

и использовать отрицательный шаг:

msg[::-1]

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

Строка – неизменяемый объект

Далее, при работе со строками следует помнить, что это неизменяемый объект, то есть, мы не можем изменять в строковом объекте уже существующие символы. Тогда как в Python нам изменять строки? Для этого создается новая строка с нужным содержимым. Например, изменим строку

«Hello World!»

на строку

«Hello word!»

Это можно сделать так:

msg = "Hello World!"
myStr = msg[:6]+"w"+msg[7:9]+msg[10:]
print(myStr)

В результате строка myStr ссылается на новую измененную строку, а msg осталась прежней.

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

1. Напишите программу подсчета букв ‘a’ в строке «abrakadabra».

2. Из строки «abrakadabra» удалите все сочетания «ab».

3. Напишите программу определения слова палиндрома (это слова, которые одинаково читаются в обоих направлениях, например, анна, abba и т.п.). Слово вводится с клавиатуры.

4. Напишите программу определения количества вхождений фраз «ra» в слове «abrakadabra».

5. Разделите введенное с клавиатуры предложение на слова (слова разделяются пробелом).

Методы строк в 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

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

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]]): разбивает строку на подстроки в зависимости от разделителя

partition(delimeter): разбивает строку по разделителю на три подстроки и возвращает кортеж из трех элементов – подстрока до разделителя, разделитель и подстрока после разделителя

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

https://www.youtube.com/watch?v=4LDjbKQS9PA&list=PLA0M1Bcd0w8xIdFNA95aQrwJ_GQJEV8ko