11(b)-Lesson №20

Если в середине XX века первые компьютеры использовались главным образом для выполнения сложных математических расчётов, сейчас их основная работа — обработка текстовой (символьной) информации.

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

Основной тип данных для работы с символьными величинами в языке Python — это символьные строки (тип str).

Для того чтобы записать в строку значение, используют оператор присваивания

s = "Вася пошёл гулять"

Строка заключается в кавычки или в апострофы. Если строка ограничена кавычками, внутри неё могут быть апострофы, и наоборот.

Для ввода строки с клавиатуры применяют функцию input:

s = input("Введите имя: ")

Длина строки определяется с помощью функции 1еп (от англ. length — длина). В этом примере в переменную n записывается длина строки s:

n = len(s)

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

print (s[5])

Отрицательный индекс говорит о том, что отсчёт ведётся с конца строки. Например, s[-1] означает то же самое, что s[len(s)-1], т. е. последний символ строки.

В отличие от большинства современных языков программирования в Python строка — это неизменяемый объект. Поэтому оператор присваивания s [5] = «а» не сработает — будет выдано сообщение об ошибке.

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

s = input("Введите строку:") 
s1 = "" 
for с in s:
    if с == "a": 
        с = "б"
    s1 = s1 + с 
print(si)

Здесь в цикле for с in s перебираются все символы, входящие в строку s. Каждый из них на очередном шаге записывается в переменную с. Затем мы проверяем значение этой переменной: если оно совпадает с буквой «а», то заменяем его на букву «б», и прицепляем в конец новой строки s1 с помощью оператора сложения.

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

Как мы уже видели, оператор + используется для объединения (сцепления) строк (англ, concatenation), эта операция иногда называется конкатенация (от лат. catena — цепь). Например:

s1="Привет"
s2="Вася"
s=s1 + ", " + s2 + "!"

В результате выполнения приведённой программы в строку s будет записано значение

"Привет, Вася!".

Для того чтобы выделить часть строки (подстроку), в языке Python применяется операция получения среза (англ, slicing), например s [ 3:8 ] означает символы строки s с 3-го по 7-й (т. е. до 8-го, не включая его). Следующий фрагмент копирует в строку s1 символы строки s с 3-го по 7-й (всего 5 символов):

s = ”0123456789”
s1 = s[3:8]

В строку s1 будет записано значение ”34567”.

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

s = ”0123456789”
s1 = s[:3] + s[9:]

Срез s [: 3 ] означает «от начала строки до символа s [ 3 ], не включая его», а запись s [ 9: ] — «все символы, начиная с s [ 9] до конца строки». Таким образом, в переменной s1 остаётся значение ”0129”.

С помощью срезов можно вставить новый фрагмент внутрь строки:

s = ”0123456789”
s1 = s [ :3] + "АВС” + s[3:]

Переменная s получит значение «012АВС3456789».

Если заданы отрицательные индексы, к ним добавляется длина строки N. Таким образом, индекс -1 означает то же самое, что N — 1. При выполнении команд

s = "0123456789"
s1=s[:-1]           # "012345678"
s2=s[-6:-2]         # "4567"

мы получим s1 = «012345678» (строка s кроме последнего символа) и s2 = «4 5 67».

Срезы позволяют выполнить реверс строки (развернуть её наоборот):

s1 = s[::—1]

Так как начальный и конечный индексы элементов строки не указаны, задействована вся строка. Число -1 означает шаг изменения индекса и говорит о том, что все символы перебираются в обратном порядке.

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

s = "аАЬВсС"
s1 = s.upper() # "ААВВСС"
s2 = s.lower() # "aabbcc"

а метод isdigit проверяет, все ли символы строки — цифры, и возвращает логическое значение:

s = "abc"
print(s.isdigit() ) # False
s1 = "123"
print(s1.isdigit()) # True

О других встроенных функциях вы можете узнать в литературе или в Интернете.

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

s = "Здесь был Вася." 
n = s.find("с")        # n = 3
if п >= 0:
    print("Номер символа", n) 
else:
    print("Символ не найден.")

Метод find возвращает целое число — номер символа, с которого начинается образец (буква «с») в строке s. Если в строке несколько образцов, функция находит первый из них. Если образец не найден, функция возвращает -1. В рассмотренном примере в переменную n будет записано число 3.

Аналогичный метод rfind (от англ, reverse find — искать в обратную сторону) ищет последнее вхождение образца в строке. Для той же строки s, что и в предыдущем примере, метод rfind вернёт 12 (индекс последней буквы «с»):

s="Здесь был Вася."
n=s.rfind("с")                    # n=12

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

Василий Алибабаевич Хрюндиков

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

Хрюндиков В.А.

Возможный алгоритм решения этой задачи может быть на псевдокоде записан так:

ввести строку s
найти в строке s первый пробел
имя = всё, что слева от первого пробела
удалить из строки s имя с пробелом
найти в строке s первый пробел
отчество = всё, что слева от первого пробела
удалить из строки s отчество с пробелом
                           # осталась фамилия 
s = s + " " + имя[0] + "." + отчество[0] + "."

Мы последовательно выделяем из строки три элемента: имя, отчество и фамилию, используя тот факт, что они разделены одиночными пробелами. После того как имя будет сохранено в отдельной переменной, в строке s останутся только отчество и фамилия. После «изъятия» отчества остаётся только фамилия. Теперь нужно собрать строку-результат из частей: «сцепить» фамилию и первые буквы имени и отчества, поставив пробелы и точки между ними.

Для выполнения всех операций будем использовать срезы и метод find. Приведём сразу полную программу:

s = input("Введите имя, отчество и фамилию:") 
n = s.find(" ")
name = s[:n]        # вырезать имя
s = s [ n+1:] 
n = s.find(" ")
name2 = s[:n].      # вырезать отчество
s = s[n+l:]         # осталась фамилия
s = s + " " + nаmе[0] + "." + name2[0] + "." 
print(s)

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

f io = s.split()

Если входная строка правильная (соответствует формату, описанному в условии), то в этом списке будут три элемента: fio [0] — имя, fio[1] — отчество и fio [2] — фамилия. Теперь остаётся только собрать строку-результат в нужном виде:

s = f io [2] + " " + f io [0] [0] + + fio [1] [0] + 11.11

Запись fio[0] [0] обозначает «0-й символ из 0-го элемента списка fio», т. е. первая буква имени. Аналогично fio [ 1 ] [0] — это первая буква отчества. Вот полная программа:

s = input ("Введите имя, отчество и фамилию:11)
fio = s.split()
s = fio [2] + " " + fio [0] [0] + " + fio [1] [0] + 11.11
print(s)

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

int — переводит строку в целое число;

float — переводит строку в вещественное число;

str — переводит целое или вещественное число в строку.

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

s = "123"
N = int (s)            # N=123
s = "123.456" 
X = float(s)           # X=123.456

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

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

N = 123
s = str(N)       # s = "123"
X = 123.456
s = str(X)       # s = "123.456"

Эти операции всегда выполняются успешно (ошибки быть не может).

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

s = "{:5d)".format(N)

значение переменной N будет записано по формату d (целое число) в 5 позициях, т. е. в начале строки будут стоять два пробела:

_ _123

Для вещественных чисел можно использовать форматы f (с фиксированной точкой) и е (экспоненциальный формат, с плавающей точкой):

X = 123.456
s = "{:7.2f}".format(X)      # s = "_123.46"
s = "{:10.2e}".format(X)     # s = "__1.23е+02"

В первом случае формат 7.2f обозначает «вывести в 7 позициях с 2 знаками в дробной части», во втором — формат 10.2е обозначает «вывести научном формате в 10 позициях с 2 знаками в дробной части».

Выполнить домашнюю работу

Выполнить классную работу