Строки

str

class str([obj, encode, errors='strict'])

Возвращает str, преобразованный из объекта

Через атрибут errors настраивается обработка ошибок:

  • strict - при ошибке возбуждается исключение UnicodeDecodeError
  • replace - неизвестный символ заменяется символом, имеющим код uFFFD
  • ignore - неизвестные символы игнорируются
str()
# ''

str(125)
# '125'

str([1, 2, 3])
# '[1, 2, 3]'

str((1, 2, 3))
# '(1, 2, 3)'

str({"x": 5, "у": 10})
# "{'у': 10, 'х': 5}"

str(bytes("строка", "utf-8"))
# "b'\\xd1\\x81\\xd1\\x82\\xd1\\x80\\xd0\\xbe\\xd0\\xba\\xd0\\хbО'"

str(bytearray("строка", "utf-8") )
# "bytearray(b'\\xd1\\x81\\xd1\\x82\\xd1\\x80\\xd0\\xbe\\xd0\\xba\\xdO\\xbO')"

str(bytes("строка1", "utf-8"), "utf-8")
# 'строка1'

str(bytes("строка1", "utf-8"), "ascii", "strict")
# Traceback (most recent са11 1ast):
#   Fi1e "<pyshe11#16>", 1ine 1, in <modu1e>
#     str(bytes("строка1", "utf-8"), "ascii", "strict")
# UnicodeDecodeError: 'ascii' codec can't decode byte Oxd1 in position 0: ordina1 not in range(128)

str(bytes("строка1", "utf-8"), "ascii", "ignore")
# '1'

# вернет строку не зависима от типа аргумента
str(b"\xf1\xf2\xf0\xee\xea\xe0")
"b'\\xf1\\xf2\\xf0\\xee\\xea\\xe0'"

# вернет строку именно из типа bytes или bytearray
str(b"\xf1\xf2\xf0\xee\xea\xe0", "ср1251")
# 'строка'
"однострочная строка"
"однострочная \'строка\'"
'однострочная строка'
'однострочная \"строка\"'
"""многострочная строка"""
'''многострочная строка'''
'ilnurgi' + '.ru'
# 'ilnurgi.ru'

'ilnurgi' * 3
#'ilnurgiilnurgiilnurgi'

'il' in 'ilnurgi'
# True

'il' not in 'ilnurgi'
# False

'ilnurgi'[0]
# 'i'

'ilnurgi'[2]
# 'n'

'ilnurgi'[:2]
# 'il'

'ilnurgi'[-2:]
# 'gi'
static maketrans(x[, y[, z]])

Создает и возвращает таблицу символов

  • Если указан только первый параметр, то он должен быть словарем:

    t = str.maketrans({"a": "А", "о": "О", "с": None})
    # t = {1072: 'А', 1089: None, 1086: 'О'}
    
    "cтpoкa".translate(t)
    # 'трОкА'
    
  • Если указаны два первых параметра, то они должны быть строками одинаковой длины:

    t = str.maketrans("абвгдежзи", "АБВГДЕЖЗИ")
    # t = {1072: 1040, 1073: 1041, ...}
    
    "aбвгдeжзи".translate(t)
    # 'АБВГДЕЖЗИ'
    
  • В третьем параметре можно дополнительно указать строку из символов, которым будет сопоставлено значение None:

    t = str.maketrans("123456789", "О" * 9, "str")
    # t = {116: None, 115: None, 114: None, 49: 48, ююю}
    
    "strl23456789str".translate(t)
    # '000000000'
    
capitalize()

Возвращает новую строку, str, у которой первая буква заменена на прописную

'ilnur'.capitalize()
# 'Ilnur'
center(width[, pad])

Возвращает новую строку, str, заданной длины, выравненная по центру.

'ilnur'.center(7)
# ' ilnur '
count(sub[, start[, end]])

Возвращает int, количество вхождений искомой строки в исходной строке.

'Help me! Help!'.count('Help')
# 2
decode([coding, errors])

Возвращает новую юникодную строку, unicode, раскодированная из указанной кодировки в юникод.

'\xd0\xb8\xd0\xbb\xd1\x8c\xd0\xbd\xd1\x83\xd1\x80'.decode('utf-8')
# u'\u0438\u043b\u044c\u043d\u0443\u0440'
encode([coding, errors])

Возвращает новую строку, str, закодированную из юникода в указанную кодировку.

u'Ильнур'.encode('cp1251')
# '\xc8\xeb\xfc\xed\xf3\xf0'
endswith(sub[, start[, end]])

Возвращает bool, строка заканчивается c искомой строки

'ilnur'.endswith('il')
# False

'ilnur'.endswith('nur')
# True
expandtabs([tabsize=8])

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

u'\tИльнур'.expandtabs()
# u'        \u0418\u043b\u044c\u043d\u0443\u0440'
find(sub[, start[, end]])

Возвращает int, позиция, в котором встречается искомая строка, если ничего не найдено возвращает -1, поиск ведется слева.

'ilnur'.find('nur')
# 2

'ilnur'.find('run')
# -1
format(*args, **kwargs)

Возвращает новую строку, str, форматированную в соответствии с переданными параметрами

Синтаксис: {[Поле][!Функция][:Формат]}

Синтаксис формата: [[Заполнитель] Выравнивание] [Знак] [#] [0] [Ширна] [,] [.Точность] [Преобразование]

  • заполнитель - заполнитель пространства в поле

  • выравнивание - выравниваение поля

    • < - по левому краю
    • > - по правому краю
    • ^ - по центру
    • ‘=’ - знак числа по левому краю, число по правому
  • ширина - ширина поля

    "'{0:10}'".format(3)
    # '         3'
    
    "'{0:{1}}'".format(3, 10)
    # '         3'
    
  • знак - управляет выводом знака числа

    • + - обязательный вывод знаков
    • - - знаки только для отрицательных
    • пробел - вывод отрицательных знаков и пробел вместо положительного знака
  • преобразование - преобразование чисел

    • b - двоичное значение
    • c - преобразование числа в символ
    • d - десятичное значение
    • n - аналогично d, но с учетом локали
    • o - восьмиричное значение
    • x, ‘X’ - шестнадцатиричное значение
    • f, F - вещественное число в десятичном представлении
    • e, E - вещественное число в экспоненциальной форме
    • g, G - эквивалентно f, e или E (выбирается более короткая запись числа)
    • n - аналогично g, но учитвает локаль
    • % - умножает число на 100 и добавляет символ процента в конце
    • `` -
    • `` -
    • `` -
    • `` -
'{0} и {1}'.format('фарш', 'яйца')
# 'фарш и яйца'

'Этот {food} — {adjective}.'.format(food='фарш', adjective='непередаваемо ужасен')
# Этот фарш — непередаваемо ужасен.

'История о {0}е, {1}е, и {other}е.'.format('Билл', 'Манфред', other='Георг')
# История о Билле, Манфреде, и Георге.

'Значение ПИ — примерно {0:.3f}.'.format(3.14))
# Значение ПИ — примерно 3.14159.

'{0:10} ==> {1:10d}'.format('Sjoerd', 4127)
# Sjoerd     ==>       4127

table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
'Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; Dcab: {0[Dcab]:d}'.format(table))
# Jack: 4098; Sjoerd: 4127; Dcab: 8637678'

# вывод в двоичном формате
'{0:b} & {1:b} = {2:b}'.format(100, 75, 100 & 75)
# '1100100 & 1001011 = 1000000'
index(sub[, start[, end]])

Возвращает int, позиция, в котором встречается искомая строка, если ничего не найдено вызовет исключение ValueError, поиск ведется слева.

'ilnur'.index('nur')
# 2

'ilnur'.index('run')
"""
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
ValueError: substring not found
"""
isalpha()

Возвращает bool, строка содержит только буквы

'123'.isalpha()
# False

'ilnur'.isalpha()
# True
isalnum()

Возвращает bool, строка содержит только буквы и цифры

isdigit()

Возвращает bool, строка содержит только цифры

'123'.isdigit()
# True

'ilnur'.isdigit()
# False
isdecimal()

Возвращает bool, строка содержит только десятичные символы

islower()

Возвращает bool, строка содержит только строчные буквы

isnumeric()

Возвращает bool, строка содержит только числовые символы

"\u2155".isnumeric()
# True

"\u2155".isdigit()
# False

print("\u2155")
# '1/5'
isspace()

Возвращает bool, строка содержит только пробельные символы

'123'.isalpha()
# False
istitle()

Возвращает bool, строка содержит слова начинающиеся с заглавной буквы

isupper()

Возвращает bool, если строка содержит только заглавные буквы

join(iter)

Возвращает строку str, содержащий сконкатенированные значения исходной строки с итерируемым объектом.

'ilnur'.join('---')
# '-ilnur-ilnur-
ljust(width[, fill])

Возвращает новую строку str, заданной длины, выравненная слева.

'ilnur'.ljust(7)
# 'ilnur  '
lower()

Возвращает новую строку str, в нижнем регистре

'iLnur'.lower()
'ilnur'
lstrip([chrs=" "])

Возвращает новую строку str, с удаленными пробелами слева

' ilnur privet '.lstrip()
# 'ilnur privet  '
partition(sep)

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

  • первый элемент - содержать фрагмент, расположенный перед разделителем
  • второй элемент - символ-разделитель
  • третий эле­мент - фрагмент, расположенный после символа-разделителя.

Поиск производится сле­ва направо.

Если символ-разделитель не найден, то первый элемент кортежа будет со­держать всю строку, а остальные элементы будут пустыми.

"wordl word2 wordЗ".partition(" ")
# ('wordl', ' ', 'word2 word3')

"wordl word2 wordЗ".partition("\n")
# ('wordl word2 wordЗ', '', '')
replace(old, new[, maxreplace])

Возвращает новую строку str, с замененой строкой на новую строку.

'ilnur'.replace('nur','nurgi')
# 'ilnurgi'
rfind(sub[, start[, end]])

Возвращает int, позиция с которого начинается искомая строка, если ничего не найдено возвращает -1, поиск ведется справа.

Аналог find().

rindex(sub[, start[, end]])

Возвращает int, позиция с которого начинается искомая строка, если ничего не найдено вызовет исключение ValueError, поиск ведется справа.

Аналог index().

rjust(width[, fill])

Возвращает новую строку str, заданной длины, выравненная по правому краю.

'ilnur'.rjust(7)
# '  ilnur'
rpartition(sep)

Аналогично методу str.partition(), но поиск символа­ разделителя производится не слева направо, а, справа налево.

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

"wordl word2 wordЗ".rpartition(" ")
# ('wordl word2', ' ', 'wordЗ')

"wordl word2 wordЗ".rpartition("\n")
# (' ', '', 'wordl word2 word3')
rsplit([razd, maxcount])

Возвращает list, полученный из строки, путем разделения разделителем.

'i l n u r'.split(' ')
# ['i', 'l', 'n', 'u', 'r']
rstrip([chrs=" "])

Возвращает новую строку str, с удаленными пробелами справа

' ilnur privet '.rstrip()
# ' ilnur privet'
split([sep[, maxcount]])

Возвращает list, полученный из строки, путем разделения разделителем.

'i l n u r'.split(' ')
# ['i', 'l', 'n', 'u', 'r']
splitlines([keepends=1])

Возвращает list, аналогично split(), но использующий в качестве разделителя переход на новую строку.

Символы перехода на новую строку включаются в результат, только если необязательный аргумент keepends равен 1.

"""Hello World!\nHello!""".splitlines()
# ['Hello World!', 'Hello!']
startswith(sub[, start[, end]])

Возвращает bool, если строка начинается c искомой строки

'ilnur'.startswith('il')
# True

'ilnur'.startswith('nur')
# False
strip([chrs=" "])

Возвращает новую строку str, с удаленными пробелами c обоих концов соответственно.

' ilnur '.strip()
# 'ilnur'
swapcase()

Возвращает новую строку str, в которой регистр букв изменен с верхнего на нижний и наоборот.

'Ilnur'.swapcase()
# 'iLNUR'
title()

Возвращает новую строку str, в которой регистр букв соответствует заголовку.

'ilnur'.title()
# 'ILNUR'
translate(table[, deletechars])

Выполняет преобразование строки в соответствии с таблицей замены.

Упростить создание таблицы символов позволяет статический метод maketrans()

s = "Пример"
d = {ord('П''): None, ord('p'): ord('P')}
# d = {1088: 1056, 1055: None}
s.translate(d)
# s = 'РимеР'
upper()

Возвращает новую строку str, в верхнем регистре

'iLnur'.upper()
# 'ILNUR'
zfill(width)

Возвращает новую строку str, заданной длины, пустое пространство слева заполнится нулями

'12'.zfill(5)
# '00012'

unicode

class unicode

Юникодная строка, имеет теже методы что и str

Экранированные последовательности

Строка Описание
\ слеш
\’ апостроф
\” кавычки
\a ascii-символ звуковой сигнал
\b ascii-символ забоя
\f ascii-символ перевода формата
\n ascii-символ новой строки
\N{имя} именованный символ юникода (юникод)
\r ascii-символ возврата каретки
\t ascii-символ горизонтальной табуляции
\uXXXX 16-ый код 16-й битного сивола (юникод)
\UXXXXXXXX 16-ый код 32-й битного сивола (юникод)
\v ascii-символ вертикальной табуляции
\000 8-ный код символа
\xhh 16-ый код символа