Строки

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

In [1]:
s='Какая-нибудь строка \u00F6 \u03B1'
print(s)

Какая-нибудь строка ö α
In [2]:
'Эта строка может содержать " внутри'
Out[2]:
'Эта строка может содержать " внутри'
In [3]:
"Эта строка может содержать ' внутри"
Out[3]:
"Эта строка может содержать ' внутри"
In [4]:
s='Эта содержит и \', и \"'
print(s)

Эта содержит и ', и "
In [5]:
s="""Строка,
занимающая
несколько
строчек"""
print(s)

Строка,
занимающая
несколько
строчек
In [6]:
s=="Строка,\nзанимающая\nнесколько\nстрочек"
Out[6]:
True

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

In [7]:
s='Такие ' 'строки ' 'слипаются'
print(s)

Такие строки слипаются
In [8]:
print('Такие\n'
     'строки\n'
     'слипаются')

Такие
строки
слипаются

В питоне нет специального типа char, его роль играют строки длины 1. Функция ord возвращает (юникодный) номер символа, а обратная ей функция chr возвращает символ (строку длины 1).

In [9]:
n=ord('а')
n
Out[9]:
1072
In [10]:
chr(n)
Out[10]:
'а'

Функция len возвращает длину строки. Она применима не только к строкам, но и к спискам, словарям и многим другим типам, про объекты которых разумно спрашивать, какая у них длина.

In [11]:
s='0123456789'
len(s)
Out[11]:
10

Символы в строке индексируются с 0. Отрицательные индексы используются для счёта с конца: s[-1] - последний символ в строке, и т.д.

In [12]:
s[0]
Out[12]:
'0'
In [13]:
s[3]
Out[13]:
'3'
In [14]:
s[-1]
Out[14]:
'9'
In [15]:
s[-2]
Out[15]:
'8'

Можно выделить подстроку, указав диапазон индексов. Подстрока включает символ, соответствующий началу диапазона, но не включает соответствующий концу. Удобно представлять себе, что индексы соответствуют положениям между символами строки. Тогда подстрока s[n:m] будет расположена между индексами n и m.

индексы

In [16]:
s[1:3]
Out[16]:
'12'
In [17]:
s[:3]
Out[17]:
'012'
In [18]:
s[3:]
Out[18]:
'3456789'
In [19]:
s[:-1]
Out[19]:
'012345678'
In [20]:
s[3:-2]
Out[20]:
'34567'

Если не указано начало диапазона, подразумевается от начала строки; если не указан его конец - до конца строки.

Строки являются неизменяемым типом данных. Построив строку, нельзя изменить в ней один или несколько символов. Операции над строками строят новые строки - результаты, не меняя своих операндов. Сложение строк означает конкатенацию, а умножение на целое число (с любой стороны) - повторение строки несколько раз.

In [21]:
s='abc'; t='def'
s+t
Out[21]:
'abcdef'
In [22]:
s*3
Out[22]:
'abcabcabc'

Операция in проверяет, содержится ли символ (или подстрока) в строке.

In [23]:
'a' in s
Out[23]:
True
In [24]:
'd' in s
Out[24]:
False
In [25]:
'ab' in s
Out[25]:
True
In [26]:
'b' not in s
Out[26]:
False

У объектов типа строка есть большое количество методов. Метод lstrip удаляет все whitespace-символы (пробел, tab, newline) в начале строки; rstrip - в конце; а strip - с обеих сторон. Им можно передать необязательный аргумент - символы, которые нужно удалять.

In [27]:
s='   строка   '
s.lstrip()
Out[27]:
'строка   '
In [28]:
s.rstrip()
Out[28]:
'   строка'
In [29]:
s.strip()
Out[29]:
'строка'

lower и upper переводят все буквы в маленькие и заглавные.

In [30]:
s='СтРоКа'
s.lower()
Out[30]:
'строка'
In [31]:
s.upper()
Out[31]:
'СТРОКА'

Проверки: буквы (маленькие и заглавные), цифры, пробелы.

In [32]:
'АбВг'.isalpha()
Out[32]:
True
In [33]:
'абвг'.islower()
Out[33]:
True
In [34]:
'АБВГ'.isupper()
Out[34]:
True
In [35]:
'0123'.isdigit()
Out[35]:
True
In [36]:
' \t\n'.isspace()
Out[36]:
True

Строки имеют тип str.

In [37]:
type(s)
Out[37]:
str
In [38]:
s=str(123)
s
Out[38]:
'123'
In [39]:
n=int(s)
n
Out[39]:
123
In [40]:
int('123x')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-40-528edaa9c06f> in <module>()
----> 1 int('123x')

ValueError: invalid literal for int() with base 10: '123x'
In [41]:
x=float('123.456E-7')
x
Out[41]:
1.23456e-05

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

In [42]:
f's = {s},  n = {n},  x = {x}'
Out[42]:
's = 123,  n = 123,  x = 1.23456e-05'

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

In [43]:
print(f'"{s:5}"  "{n:5}"  "{x:5}"')

"123  "  "  123"  "1.23456e-05"

Целые числа можно печатать в десятичном, шестнадцатиричном или двоичном виде.

In [44]:
print(f'десятичное "{n:5d}",  16-ричное "{n:5x}",  двоичное "{n:5b}"')

десятичное "  123",  16-ричное "   7b",  двоичное "1111011"

Для чисел с плавающей точкой можно задать число цифр после точки и формат с фиксированной точкой или экспоненциальный.

In [45]:
print(f'{x:10.5f} {x:10.5e} {1/x:10.5f} {1/x:10.5e}')

   0.00001 1.23456e-05 81000.51840 8.10005e+04