курсовая. Основы работы со строками

• Название: Основы работы со строками
• Анкор: курсовая
• Дата: 12.03.2022
• Размер: 146.26 Kb.
• Имя файла: 8__._._.docx
• Тип: Документы; #392961

Основы работы со строками

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

str1 = 'Hello1'

str2 = "Hello2"

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

str3 = '''Многострочные

строки 1''';

 

str4 = """Многострочные

строки2""";

print(str1)

print(str2)

print(str3)

print(str4)

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

'''hello

world'''

то при выводе после hello увидим символ \n, который и означает перевод строки. Функция print обрабатывая этот символ делает перевод строки:

print('hello\nworld')

Если в кавычках ничего не записано:

str0 = ""

то это будет пустая строка, не содержащая никаких символов.

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

str1 = "сообщение"

и мы другой переменной присвоим первую:

str2 = str1

то получим две ссылки на один и тот же объект (одну строку). То есть, копирование строки здесь не происходит!



Как создавать копии строк вы узнаете дальше из этого занятия.

Операторы и функции для строк

Первый оператор + – это соединение двух строк (или как еще говорят, конкатенация строк). Он используется так:

str1 = 'Hello'

str2 = "world!"

msg = str1+str2

print(msg)

Здесь сначала будут идти символы первой строки, а затем – второй. В результате у нас формируется новый объект, содержащий эти символы. Но у нас оба слова слились в одно. Как можно было бы добавить между ними пробел? Это можно сделать так:

msg = str1+" "+str2

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

dig = 5

msg = "число = "+dig

print(msg)

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

str(<аргумент>)

msg = "число = "+str(dig)

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

Далее, в Python довольно просто выполняется дублирование строки. Предположим, у нас есть вот такая строка:

one = 'ай '

и мы хотим ее размножить n раз. Это можно сделать так:

msg = one*10

print(msg)

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

msg = one*3.5

нельзя, произойдет ошибка.

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

len(<строка>)

Например:

N = len(msg)

print(msg, N)

Затем, для проверки наличия в строке той или иной подстроки, используется оператор in:

<подстрока> in <строка>

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

s = "abcdefg0123"

"abc" in s

'0' in s

'43' in s

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

<строка 1> == <строка 2>

Данный оператор возвращает True, если строки равны и False, если не равны. Пример:

"abc" == 'abc'

"ABC" == 'abc'

Обратите внимание, строка, записанная заглавными буквами – это в Python уже другая строка и оператор сравнения для них возвращает False.

Для сравнения неравенства строк используется оператор не равно:

<строка 1> != <строка 2>

Он возвращает True, если строки не равны и False в противном случае.

Разумеется, эти операции сравнения обычно используются в условном операторе if или операторах циклов while и for, о которых мы уже с вами говорили. Например, можно записать такую программу:

psw = "pass"

in_psw = ""

while psw != in_psw:

   in_psw = input("Введите пароль: ")

print("Вход в систему разрешен")

Здесь пользователь будет вводить пароль, пока не введет заданный, то есть, строку pass.

Также строки можно сравнивать на больше и меньше:

<строка 1> < <строка 2>
<строка 1> > <строка 2>

Здесь используется лексикографический порядок при определении: какая строка больше, а какая меньше. Мы об этом подробно говорили, когда рассматривали условный оператор if.

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

На самом деле в 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]

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

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

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

msg[0] = 'A'

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

«Hello World!»

на строку

«Hello word!»

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

myStr = msg[:6]+"w"+msg[7:9]+msg[10:]

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

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

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

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

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

string = "Hello World!"

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

String.upper()

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

string.upper()

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

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

string = string.upper()

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

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

"hello".upper()

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

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

String.lower()

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

string.lower()

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

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

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

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

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

msg = "abrakadabra"

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

msg.count("ra")

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

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



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

msg.count("ra", 4)

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

msg.count("ra", 4, 10)

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

msg.count("ra", 4, 11)

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

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

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

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

msg.find("br")

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

msg.find("br", 2)

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

msg.find("brr")

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

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

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

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

msg.rfind("br")

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

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

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

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

msg.index("brr")

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

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

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

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

msg.replace("a", 'o')

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

msg.replace("ab", "AB")

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

msg.replace("ab", "")

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

msg.replace("a", 'o', 2)

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

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

String.isalpha()

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

msg.isalpha()

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

"hello world".isalpha()

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

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

String.isdigit()

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

"5.6".isdigit()

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

"56".isdigit()

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

dig = input("Введите число: ")

if(dig.isdigit()):

   dig = int(dig)

    print(dig)

else:

   print("Число введено неверно")

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

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

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

d="abc"

d.rjust(5)

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

d.rjust(5, "-")

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

d.rjust(5, "-*")

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

d.rjust(2)

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

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

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

d.ljust(10, "*")

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

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()

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