Строки в Python

Строка - последовательность символов Unicode

Символ - строка, имеющая длину 1


"Строка символов"
'Еще одна строка символов !!!'
''  # Пустая строка

Доступ к элементам строки

>>> "Строка символов"
'Строка символов'

>>> "Строка символов"[5]
'а'

>>> "Строка символов"[8]
'и'

>>> "Строка символов"[0]
'С'
>>>

Индексы в Python начинаются с нуля
Символы можно только извлекать, но не изменять их.


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

>>> int("73475690")
73475690
>>>

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

>>> int("   73475690 ")
73475690
>>>

Проверим, что тип действительно int

>>> print (int("   73475690 "), type(int("   73475690 ")))
73475690 < class 'int '>
>>>

Преобразовать число в строку можно так:

>>> str(26540978)
'26540978'
>>>

Проверим, что тип действительно str

>>> print (str(26540978), type(str(26540978)))
26540978 < class 'str' >
>>>

Можно создать объект типа str в памяти и затем создать ссылку на на этот объект.
Например создадим объект типа str с текстом "python" и затем создадим на этот объект ссылку с именем a.

>>> a = "python"
>>> a
'python'
>>>

оператор "=" связывает ссылку на объект с объектом находящимся в памяти

Если ссылка на объект уже существует, ее легко можно связать с другим объектом:

>>> a = "jython"
>>> a
'jython'
>>>

Теперь ссылка с именем a ссылается на объект типа str с текстом "jython"

А на строку  "python" теперь ни одна ссылка не ссылается
и интерпретатор сможет утилизировать объект содержащий эту строку "сборщиком мусора".

Еще пример:

>>> a = "python"
>>> b = "jython"
>>> c = a
>>> print (a, b, c)
python jython python
>>> c = b
>>> print (a, b, c)
python jython jython
>>> a = c
>>> print (a, b, c)
jython jython jython
>>>

Теперь ни одна ссылка не ссылается на строку "python",
интерпретатор сможет утилизировать объект содержащий эту строку.

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

>>> a, b, c
('jython', 'jython', 'jython')
>>>

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


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

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

Строки в Python - это неизменяемый тип данных str, который хранит последоватедьность символов Unicode.

Строковые объекты создаются :

- при вызове функций str() или bytes()
- при манипуляции объектом типа файл созданным вызовом функции open()
- при определении строкового литерала (в одинарных, двойных или тройных кавычках)

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

>>> str()
''
>>> 

С аргументом, который является строкой - возвращается его копия :

>>> str("Oracle Java!")
'Oracle Java!'
>>>

С аргументом, который не является строкой - возвращается строковое представление аргумента :

>>> str(3.1415)
'3.1415'
>>> 

Функция str() может также использоваться как функция преобразования.
В этом случае первый аргумент должен быть объектом, который можно преобразовать в строку (например типа bytes  или bytearray)  и кроме того функции может быть передано до двух необязятельных строковых аргументов:

- один из них определяет используемую кодировку
- второй определяет порядок обработки ошибок кодирования

>>> s="Häuser Höfe Bücher"

>>> bytes(s, encoding='latin-1')
b'H\xe4user H\xf6fe B\xfccher'
 
>>> 'H\xe4user H\xf6fe B\xfccher'
'Häuser Höfe Bücher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher')
"b'H\\xe4user H\\xf6fe B\\xfccher'"
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "latin-1")
'Häuser Höfe Bücher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii")
Traceback (most recent call last):
  File "", line 1, in
    str(b'H\xe4user H\xf6fe B\xfccher', "ascii")
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 1: ordinal not in range(128)
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii", "ignore")
'Huser Hfe Bcher'
 
>>> str(b'H\xe4user H\xf6fe B\xfccher', "ascii", "replace")
'H�user H�fe B�cher'
>>>

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

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

>>> msg = """ строка текста
еще строка текста в "кавычках" и 'апострофах'
продолжение на следующей строке """
>>>
>>> msg
' строка текста\nеще строка текста в "кавычках" и \'апострофах\'\nпродолжение на следующей строке '
>>>


>>> a = "Здесь 'апострофы' можно не экранировать, а "кавычки" нужно экранировать."
SyntaxError: invalid syntax

>>> a = "Здесь 'апострофы' можно не экранировать, а \"кавычки\" нужно экранировать."

>>> a
'Здесь \'апострофы\' можно не экранировать, а "кавычки" нужно экранировать.'
>>>


>>> a = 'Здесь 'апострофы' придется экранировать, а "кавычки" можно не экранировать.'
SyntaxError: invalid syntax
 
>>> a = 'Здесь \'апострофы\' придется экранировать, а "кавычки" можно не экранировать.'
 
>>> a
'Здесь \'апострофы\' придется экранировать, а "кавычки" можно не экранировать.'
>>>


В языке Python символ перевода строки интерпретируется как завершающий символ инструкции, но
- не внутри круглых скобок  ( )
- не внутри квадратных скобок  [ ]
- не внутри фигурных скобок  { }
- не внутри тройных кавычек  """   """

В тройных кавычках символ перевода строки можно даже экранировать :

>>> s = """ aaaaaaaaaaa\
bbbbbbbbbbbbbbbbbbbbbbb
ccccccccccccc """
>>> s
' aaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbb\nccccccccccccc '
>>>

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

Мы можем вллючать символы перевода строки в любые строковые литералы с помощью экранированной последовательности \n.

 >>> s = "Строка\nНовая строка"
 
>>> s
'Строка\nНовая строка'
 
>>> print(s)
Строка
Новая строка
>>>


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


\перевод_строки    - экранирует(т.е. игнорирует) символ перевода строки

\\    - экранирует символ обратного слэша

\'     - экранирует символ апострофа

\"     - экранирует символ кавычки

\a     - символ ascii сигнал (bell, BEL)

\b     - символ ascii  забой (backspace, BS)

\f     - символ ascii  перевод формата (formfeed, FF)

\n     - символ ascii  перевод строки (linefeed, LF)

\N{название}     - символ Unicode с заданным названием

\000     - символ с заданным восьмеричным кодом (от \000 до \377)

\r     - символ ascii возврат каретки (carriage return, CR)

\t     - символ ascii табуляция (tab, TAB)

\v     - символ ascii  вертикальная табуляция (vertical tab, VT)

\uhhhh     - символ Unicode с указанным 16-битным шестнадцатеричным значением.

\Uhhhhhhhh     - символ Unicode с указанным 32-битным шестнадцатеричным значением.

\xhh     -  символ c  указанным 8-битным шестнадцатеричным значением.



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

>>> import re
>>> phone1 = re.compile("^((?:[(]\\d+[)])?\\s*\\d+(?:-\\d+)&)$")
>>>

Решить эту проблему можно используя "сырые" (raw) строки.
Это обычные строки в кавычках или тройных кавычках, в которые перед первой кавычкой добавлен символ r.

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

>>> phone2 = re.compile(r"^((?:[(]\d+[)])?\s*\d+(?:-\d+)&)$")
>>>

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

>>> m = "это длинный строковый литерал, который занимает" +\
    " вторую строку" +\
    " и даже третью"
>>> m
'это длинный строковый литерал, который занимает вторую строку и даже третью'
>>>

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

>>> m = ("это длинный строковый литерал, который занимает"
     " вторую строку"
     " и даже третью")
>>> m
'это длинный строковый литерал, который занимает вторую строку и даже третью'
>>>