Из Delphi в Python. Неизменяемые типы данных. Строки

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

Строки представляют собой упорядоченные последовательности символов и, при этом, длина строки ограничивается лишь объемом оперативной памяти. И, следовательно, учитывая то, что строки Python — неизменяемый тип данных, следует весьма и весьма аккуратно с этим типом данных работать. В особенности, если дело касается больших строк. 

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

В строках Python могут использоваться символы Unicode от U+0000 до U+10FFFF. При этом, в Python нет такого типа данных как Char (символ), вместо этого, каждый символ в последовательности представлен как строка с длинной равной 1.
Python обладает достаточно большими возможностями в плане работы со строками. И, надо сказать, что некоторыми из этих возможностей я был приятно удивлен. Начнем с самого простого — как присвоить строковое значение переменной?
В Delphi строки всегда заключаются в одинарные кавычки (апострофы), например, так:

var s: string;
begin
  s:='Привет, мир!'
end

В Python мы можем объявить строку так:

>>> s = "Привет, мир!" #создали строку
>>> s                  #получаем значение
'Привет, мир!'         #значение переменной s

а можем заключить строку в двойные кавычки:

>>> S = "I'm a string"
>>> S
"I'm a string"

И при этом, обратите внимание, что апостроф в строке был правильно интерпретирован. И даже, если в строке будет несколько апострофов — ошибки не будет. Внутри строки могут содержаться управляющие символы, например, \n (перевод строки):

>>> S="Первая строка\nВторая строка\nТретья строка"
>>> print(S)
#результат 
Первая строка
Вторая строка
Третья строка

В Python используются следующие специальные символы:

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

>>> S='строка с экранированным апострофом \' <-- вот здесь' 
>>> S
"строка с экранированным апострофом ' <-- вот здесь"

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

>>> S = "Строка в двойных кавычках с \"экранированными\" символами"
>>> S
'Строка в двойных кавычках с "экранированными" символами'

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

>>> S=r"Это строка в которой \n - это обычные символы"
>>> print(S)
Это строка в которой \n - это обычные символы

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

S = """Это очень большая строка
которая обрамляется
тройными кавычками -
это ещё один способ
задания строк в Python"""
>>> S
'Это очень большая строка\nкоторая обрамляется\nтройными кавычками -\nэто ещё один способ\nзадания строк в Python'

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

>>> def test():
	"""Это описание функции"""
	pass
 
>>> print(test.__doc__)
Это описание функции

В этом примере строка, не присвоенная никакой переменной, стала строкой документирования.

Работа со строками

Как и все последовательности в Python, строки поддерживают:

• • обращение к элементу по индексу;
  • конкатенацию;
  • повторение;
  • получение среза;
  • проверку на вхождение.

Продемонстрирую эти операции небольшими листингами.

Обращение к элементу по индексу

Первый элемент в строке Python имеет индекс 0.

>>> S = 'Строка'
>>> S[0]
'С'
>>> S[1]
'т'

Можно получить символ по индексу, но изменить его нельзя (строка в Python — неизменяемый тип данных):

>>> S = 'Строка'
>>> S[1]
'т'
>>> S[1]='А'
Traceback (most recent call last):
  File <pyshell#48>", line 1, in 
    S[1]='А'
TypeError: 'str' object does not support item assignment

Ещё одно отличие работы со строками в Python от Delphi заключается в том, что в качестве индекса мы можем указать отрицательное число — в этом случае смещение будет отсчитываться с конца строки:

>>> S = "Строка"
>>> S[-0]
'С'
>>> S[-1]
'а'

то есть значение индекса вычитается из длины строки, что наглядно демонстрирует приведенный выше пример с индексом -0.
Конкатенация строк

Здесь, с точки зрения реализации этой операции, ничего нового по сравнению с Delphi нет — для конкатенации строк используется оператор «+». При этом мы получим новый объект строкового типа, что демонстрирует вот этот код:

>>> A = "Привет, " #создали строку
>>> id(A) #получили адрес объекта
54282912 
>>> A = A+'мир!' #добавили к строке ещё одну строку
>>> id(A) #получаем адрес
54275104 #новый адрес объекта

В случае конкатенации строки и какого-либо другого типа данных, например числа, необходимо также как и Delphi преобразовать тип:

>>> "Число "+str(10)
'Число 10'

Повторение
«Размножить» строку в Python позволяет оператор «*» (умножение). Происходит это вот так:

>>> "Привет "*3
'Привет Привет Привет '

Получение среза
Операция извлечения среза возвращает указанный фрагмент строки и имеет следующий формат:
[::]
Все параметры у операции среза — необязательные. При этом используются следующие правила:

1. Если не указан параметр «Начало», то используется значение 0;
2. Если не указан параметр «Конец», то возвращается фрагмент до конца строки; символ с индексом, указанном в этом параметре не входит во фрагмент, возвращаемый операцией;
3. Если не указан параметр «Шаг», то используется значение 1.

Посмотрим, как работает операция извлечения среза. Вначале получим всю строку целиком:

>>> s = 'Тестовая строка'
>>> s[:]
'Тестовая строка'

Здесь мы опустили сразу все параметры операции среза — начало, конец и шаг. Эту же самую строку мы могли бы получить и так:

>>> s[::1]
'Тестовая строка'

и вот так:

>>> s[0::1]
'Тестовая строка'

И, даже вот так:

>>> s[0:len(s):1]
'Тестовая строка'

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

>>> s[1::2]
'етвясрк'

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

>>> s[:1] #получаем первый символ
'Т'
>>> s[-1:] #получаем последний символ
'а'

А так мы можем вывести символы с индексами 2,3,4 и 5

>>> s[2:6] #не используем параметр "Шаг"
'стов'

В приведенном выше примере, следуя правилам получения среза, символ с индексом 6 не вошел в результат среза.

Проверка на вхождение
Проверка на вхождение осуществляется с использованием операторов in или not in (невхождение):

>>> "Стр" in "строка"
False
>>> "Стр" in "Строка"
True

Или так

>>> "Delphi" not in "Python"
True

 
Собственно, на данный момент — это всё, что можно сказать про работу со строками в Python. «За бортом»
пока остались такие интересные моменты, как форматирование строк, использование различных методов для работы со строками в Python, но к этим и другим вопросам я обязательно вернусь в свое время. когда более менее нормально освоюсь с типами данных в Python.

Книжная полка

	Автор:Владимир Дронов Название: Python 3. Самое необходимое Описание Описан базовый синтаксис языка Python 3: типы данных, операторы, условия, циклы, регулярные выражения, встроенные функции, классы и объекты, итераторы и перечисления, обработка исключений, часто используемые модули стандартной библиотеки	Купить на ЛитРес
	Автор: Майк МакГрат Название: Python. Программирование для начинающих Описание: Книга «Программирование на Python для начинающих» является исчерпывающим руководством для того, чтобы научиться программировать на языке Python. В этой книге с помощью примеров программ и иллюстраций, показывающих результаты работы кода, разбираются все ключевые аспекты языка. Установив свободно распространяемый интерпретатор Python, вы с первого же дня сможете создавать свои собственные исполняемые программы!	Купить на ЛитРес