Методы строк

str.capitalize()¶: Возвращает копию строки в которой только первый символ находится в верхнем регистре, а все остальные в нижнем.

>>> 'python'.capitalize()
'Python'
>>> 
>>> 'pYTHON'.capitalize()
'Python'
>>> 
>>> 'pYtHoN'.capitalize()
'Python'

str.casefold()¶: Возвращает копию строки в которой все символы приводятся к нижнему регистру в соответствии с разделом 3.13 стандарта Юникода.

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

>>> '\u1e9e', '\u1e9e'.casefold(), '\u1e9e'.lower()
('ẞ', 'ss', 'ß')
>>> 
>>> '\u0587', '\u0587'.casefold(), '\u0587'.lower()
('և', 'եւ', 'և')
>>> 
>>> '\uabae', '\uabae'.casefold(), '\uabae'.lower()
('ꮮ', 'Ꮮ', 'ꮮ')

str.center(width[, fillchar])¶: Возвращает новую строку длинной width в которой исходная строка находится в центре, а справа и слева от нее находятся символы указанные в fillchar (по умолчанию пробел).

>>> 'A'.center(11)
'     A     '
>>> 'A'.center(11, 'a')
'aaaaaAaaaaa'

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

>>> 'A'.center(3, 'Х')
'ХAХ'
>>> 'A'.center(4, 'Х')
'ХAХХ'

Исходная строка возвращается без изменений, если width < len(str):

>>> 'ABCDEFG'.center(5)
'ABCDEFG'

str.count(sub[, start[, end]])¶: Возвращает количество вхождений строки sub в строке str.

>>> s = 'aaAaaBaaCaaDaaE'
>>> s.count('aa')
5

Подсчитываются только непересекающиеся последовательности символов, т.е. в строке 'aaaa' будет насчитано всего две строки 'aa':

>>> 'aaaa'.count('aa')
2

Фактически, подсчет выполняется внутри среза str[start : end], где start = 0 и end = None, что равносильно поиску по всей строке. Данные параметры интерпретируются как границы среза и могут принимать отрицательные значения:

>>> s = 'aaXaaXaaXaaXaaXaaX'
>>> 
>>> s.count('X')    #  Подсчет по всей строке
6
>>> 
>>> s.count('X', 8)    #  Подсчет в срезе s[8:], равносильно s.count('X', -10)
4
>>> 
>>> s.count('X', 0, 8)    #  Подсчет в срезе s[:8], равносильно s.count('X', -18, -10)
2
>>>
>>> s.count('X', 8, 14)    #  Подсчет в срезе s[8:14], равносильно s.count('X', -10, -4)
2

str.encode(encoding="utf-8", errors="strict")¶: Декодирует строку str в указанную в параметре encoding кодировку и возвращает результат в виде строки типа bytes.

>>> s = 'Английский Russian'
>>> 
>>> s.encode(encoding = 'koi8_r')
b'\xe1\xce\xc7\xcc\xc9\xca\xd3\xcb\xc9\xca Russian'

Параметр errors позволяет определить необходимое поведение если декодирование невозможно:

>>> s.encode(encoding = 'ascii')    #  декодирование невозможно
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-9: ordinal not in range(128)
>>> 
>>> 
>>> s.encode(encoding = 'ascii', errors = 'ignore')    #  игнорируем непереводимые символы
b' Russian'
>>> 
>>> s.encode(encoding = 'ascii', errors = 'replace')    #  заменяем непереводимые символы на '?'
b'?????????? Russian'

str.endswith(suffix[, start[, end]])¶: Возвращает True если str заканчивается последовательностью символов suffix и False в противном случае.

>>> 'ABCDEFG'.endswith('FG')
True
>>> 
>>> 'ABCDEFG'.endswith('FH')
False
>>> 
>>> 'ABCDEFG'.endswith('')    #  все строки заканчиваются пустой строкой
True
>>> ''.endswith('')    #  даже пустые
True

Фактически, наличие конечных символов suffix определяется внутри среза str[start : end], где start = 0 и end = None, что равносильно поиску по всей строке. Данные параметры интерпретируются как границы среза и могут принимать отрицательные значения:

>>> s = 'ABCDEFG'
>>> 
>>> s.endswith('DEFG', 1)    #  срез s[1:] оканчивается 'DEFG' ?
True
>>> s.endswith('DEFG', 4)    #  а срез s[4:] оканчивается 'DEFG' ?
False
>>> 
>>> s.endswith('DE', 1, 5)    #  а срез s[1:5] оканчивается 'DE' ?
True
>>> 
>>> s.endswith('DE', -6, -2)    #  то же самое но с отрицательными индексами
True

str.expandtabs(tabsize=8)¶: Разбивает строку по символам \t на столбцы указанной ширины.

>>> s = '0\t1\t22\t333\t4444\t55555\t666666'
>>> 
>>> s.expandtabs()
'0       1       22      333     4444    55555   666666'

В данном примере все числа, находятся внутри столбцов шириной 8 символов. Но если какое-то значение не помещается внутри одного столбца, то ширина столбца будет увеличена в необходимое количество раз:

>>> s = '0\t1\t22\t333\t9999999999\t55555\t666666'
>>> 
>>> s.expandtabs()
'0       1       22      333     9999999999      55555   666666'

Число 9999999999 находится внутри столбца шириной 16 символов.

Ширина столбцов может быть указана в параметре tabsize

>>> s.expandtabs(10)
'0         1         22        333       9999999999          55555     666666'

Иногда, данный метод позволяет очень легко организовать вывод данных в виде выровненной таблицы:

>>> from random import randint
>>> 
>>> for n in range(10):
...     s = '\t'.join([str(randint(0, 1000000)) for i in range(7)])
...     print(s.expandtabs())
... 
902554  261865  861826  576748  743562  59438   991134
18485   733669  219939  878578  782800  551575  223510
118842  95140   556104  955750  732558  761624  55331
958787  208817  995586  615935  578823  380832  440263
10677   966535  760434  979777  164949  567708  413968
229494  515569  939107  508804  762052  332224  315937
671578  551127  318284  608368  700302  974537  403531
619249  930938  449912  626958  901540  971080  999180
919159  858236  38881   979280  695     890070  323412
183650  842643  638844  96394   821447  875391  132484

Символы \n и \r остаются как есть, но не влияют на изменение ширины столбцов.

str.find(sub[, start[, end]])¶: Возвращает индекс первого вхождения строки sub в строке str.

>>> s.find('CC')
6

Если строка sub отсутствует внутри строки str то будет возвращена \(-1\):

>>> s.find('GG')
-1

Фактически, поиск выполняется внутри среза str[start : end], где start = 0 и end = None, что равносильно поиску по всей строке. Данные параметры интерпретируются как границы среза и могут принимать отрицательные значения:

>>> s.find('CC', 8)
18
>>> s.find('BB', 8, 22)
15

str.format(*args, **kwargs)¶: Данный метод позволяет вставить в указанные места указанные аргументы, с выполнением их предварительного форматирования.

Места для вставки аргументов обозначаются фигурными скобками {}, а в самих скобках указывается номер порядкового аргумента или имя именованного аргумента:

>>> s = 'карма: {0}, рейтинг: {1}, имя - {name}, ник - {nik_name}'
>>> 
>>> s.format(711, 1546, name = 'Sam', nik_name = 'SamProfi')
'карма: 711, рейтинг: 1546, имя - Sam, ник - SamProfi'

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

>>> 'X = {0:0<+10.5}; Y = {1:0>+3.9};'.format(10**4/7, 20/3)
'X = +1428.6000; Y = +6.66666667;'

Указание способа форматирования выполняется на основе микроязыка спецификаторов формата (подробнее на странице str.format() — метод форматирования строк)

str.format_map(mapping)¶: Тоже что и str.format(**mapping), но позволяет использовать собственные отображения (объекты типа "ключ - значение"), которые используются напряму, без копирования.

>>> class MyMap(dict):
...     def __missing__(self, key):
...         return key
... 
>>> my_map = MyMap(a = 1, b = 2, c = 3)
>>> my_map
{'a': 1, 'b': 2, 'c': 3}
>>> 
>>> 'A = {a}; B = {b}; C = {c}; X = {x}'.format_map(my_map)
'A = 1; B = 2; C = 3; X = x'

Преимущества данной функции становятся заметны, когда мы указываем ключи которых нет в отображении. Например, когда мы указали ключ {x} которого не оказалось в my_map это не привело к ошибке. Но если мы попробуем проделать то же самое для метода str.format(), то это приведет к ошибке:

>>> 'A = {a}; B = {b}; C = {c}'.format(**my_map)    #  ошибки нет
'A = 1; B = 2; C = 3'
>>> 
>>> 'A = {a}; B = {b}; C = {c}; X = {x}'.format(**my_map)    #  ошибки есть
KeyError: 'x'

Дело в том, что когда мы используем метод str.format(**mapping) все отображение копируется в словарь, а когда мы используем str.format_map(mapping), то объект-отображение используется напрямую, вместе со всеми внутренними методами, включая __missing__():

>>> class CrazyMap(dict):
...     def __missing__(self, key):
...         return 'Чувак, а бобра-то нет!!!'
... 
>>> s = 'Вставим сюда черепаху {turtle}, а сюда бобра {beaver}'
>>> 
>>> s.format_map(CrazyMap(turtle = 'Тартиллла'))
'Вставим сюда черепаху Тартиллла, а сюда бобра Чувак, а бобра-то нет!!!'

str.index(sub[, start[, end]])¶: Аналогичен методу find, лиш с тем отличием, что вызывает исключение ValueError если строка sub не найдена.

>>> s = 'AAxBBxCCxDDxAAxBBxCCxDDx'
>>> 
>>> s.index('CC')
6
>>> 
>>> s.index('GG')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

str.isalnum()¶: Возвращает True если строка не пустая и состоит только из букв и цифр.

>>> ''.isalnum()
False
>>> 
>>> '111'.isalnum()
True
>>> 
>>> 'aaa'.isalnum()
True
>>> 
>>> '111aaa'.isalnum()
True

Но если в строке имеется хотябы один не буквенный и не числовой символ, то будет возвращено False:

>>> '111.aaa'.isalnum()
False
>>> '111!@#aaa'.isalnum()
False

Любопытно то, что к буквам относятся все буквы Юникода, и не важно к какому языковому алфавиту эти буквы принадлежат:

>>> s = '\u00c0\u01a2\u01fe\u03e0'
>>> s
'ÀƢǾϠ'
>>> 
>>> s.isalnum()
True

str.isalpha()¶: Возвращает True если строка не пустая и состоит только из букв.

>>> ''.isalpha()
False
>>> 
>>> 'asd'.isalpha()
True
>>> 
>>> 'asd.1'.isalpha()
False

Под буквой понимается любой алфавитный символ базы данных Юникода (точнее символы из категорий "Lm", "Lt", "Lu", "Ll" или "Lo")

>>> s = '\u00c0\u01a2\u01fe\u03e0'
>>> s
'ÀƢǾϠ'
>>> 
>>> s.isalpha()
True

str.isdecimal()¶: Возвращает True если строка не пустая и состоит только из десятичных цифр.

>>> ''.isdecimal()
False
>>> 
>>> '1234567890'.isdecimal()
True
>>> 
>>> '1.41'.isdecimal()
False

Любопытно то, что к цифрам относятся все символы Юникода, которые могут быть использованы для записи чисел в десятичной системе счисления (категория "Nd"), например, число \(1234\) в разных языках может выглядеть по разному:

>>> s1 = '\u0031\u0032\u0033\u0034'    #  ASCII
>>> s1
'1234'
>>> 
>>> s2 = '\u0967\u0968\u0969\u096a'    #  Деванагари
>>> s2
'१२३४'
>>> 
>>> s3 = '\u17e1\u17e2\u17e3\u17e4'    #  Кхмерский
>>> s3
'១២៣៤'

И все это цифры:

>>> s1.isdecimal()
True
>>> s2.isdecimal()
True
>>> s3.isdecimal()
True

str.isdigit()¶: Возвращает True если строка не пустая и состоит только из десятичных цифр и символов, которые так же отосятся к цифрам.

>>> ''.isdigit()
False
>>> '0123456789'.isdigit()
True
>>> '0.1'.isdigit()
False
>>> 'a'.isdigit()
False

Данный метод отличается от isdecimal() тем, что воспринимает символы, которые не могут участвовать в записи десятичных цифр, но при этом сами состоят из цифр, например, символы ², ³ являются показателями степени, но считаются цифровыми и возвращается True:

>>> '\u00b2'
'²'
>>> '\u00b2'.isdigit()
True
>>> '\u00b2'.isdecimal()
False

Фактически, данный метод вернет True для любого символа Юникода у которого свойство Numeric_Type равно Digit или Decimal:

>>> '\u2460'
'①'
>>> '\u2460'.isdigit()
True

str.isidentifier()¶: Возвращает True если строка является допустимым идентификатором языка Python.

По сути, речь идет не о зарезервированных идентфикаторах – строках типа for и while), а о строках типа ValueError и False. Например:

>>> 'new'.isidentifier()    #  допустимый идентификатор
True
>>> '__new__'.isidentifier()    #  это тоже допустимый идентификатор
True
>>> '123_new'.isidentifier()    #  а это не допустимый идентификатор
False

В весьма поверхностном смысле, идентификаторы – это допустимые имена переменных, функций, классов и т.д.

str.islower()¶: Возвращает True если строка не пустая и состоит только из алфавитных строчных букв.

>>> ''.islower()
False
>>> 
>>> 'abcdefg'.islower()
True
>>> 
>>> 'abcDefG'.islower()
False

Фактически, речь идет о всех символах юникода со свойством "Ll":

>>> s = '\u0278\u1d1e\u210f\u213c'
>>> s
'ɸᴞℏℼ'
>>> 
>>> s.islower()
True

str.isnumeric()¶: Возвращает True если строка не пустая и состоит только из десятичных цифр и символов, которые так же отосятся к цифрам.

Данный метод очень похож на методы isdecimal() и isdigit(), но возвращает True так же для цифровых символов чье свойство Numeric_Type равно Numeric. Например, символ ¾:

>>> '\u00be'.isnumeric()
True
>>> 
>>> '\u00be'.isdigit()
False
>>> 
>>> '\u00be'.isdecimal()
False

str.isprintable()¶: Возвращает True если все символы в строке являются печатаемыми или если строка является пустой.

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

>>> '\u001c'
'\x1c'
>>> 
>>> print('\u001c')

>>> 
>>> '\u001c'.isprintable()
False

Вообще все символы Юникода из категорий "Other" и "Separator" считаются непечатаемыми. Кроме ASCII пробела:

>>> 'печатаемый символ'.isprintable()
True

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

>>> 'непечатаемый\nсимвол'.isprintable()
False

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

>>> ''.isprintable()
True

str.isspace()¶: Возвращает True если строка не пуста и состоит только из пробельных символов, в противном случае возвращается False.

>>> ''.isspace()
False
>>> 
>>> '               '.isspace()
True

Под пробельными символами могут пониматься все символы Юникода из категорий "Other" и "Separator", например, символ "разделитель файлов" так же считается пробельным, даже несмотря на то, что он является непечатаемым:

>>> '\u001c'.isspace()
True

str.istitle()¶: Возвращает True если строка не пустая и является строкой заголовков (см. title()).

>>> 'всем привет!'.istitle()
False
>>> 'Всем привет!'.istitle()
False
>>> 'Всем Привет!'.istitle()
True
>>> 
>>> 'Hello world!'.istitle()
False
>>> 'Hello World!'.istitle()
True

str.isupper()¶: Возвращает True если строка не пустая и все символы находятся в верхнем регистре (см. upper()).

>>> 'abcdefg'.isupper()
False
>>> 'Abcdefg'.isupper()
False
>>> 'ABCDEFG'.isupper()
True

В строке могут присутствовать пробелы:

>>> 'ABCDE FG'.isupper()
True

str.join(iterable)¶: Возвращает новую строку, которая является объединением (конкатенацией) строк из итерируемого объекта iterable через разделитель str.

>>> '|->'.join(['a12', '1b2', 'c12'])
'a12|->1b2|->c12'
>>> 
>>> ',    '.join(['a12', '1b2', 'c12'])
'a12,    1b2,    c12'
>>> 
>>> '      '.join(['a12', '1b2', 'c12'])
'a12      1b2      c12'

Если какое-то значение в iterable не является стрококй, то это приведет к ошибке:

>>> ', '.join(['a', a])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> 
>>> ', '.join(['a', 11])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 1: expected str instance, int found

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

>>> a = [1, 2, 3, 4, 5]
>>> 
>>> ' --> '.join([str(i) for i in a])
'1 --> 2 --> 3 --> 4 --> 5'

Либо отобразить функцию str() на iterable с помощью функции map():

>>> a = [1, 2, 3, 4, 5]
>>> 
>>> ' --> '.join(map(str, a))
'1 --> 2 --> 3 --> 4 --> 5'

str.ljust(width[, fillchar])¶: Возвращает новую строку в которой исходная строка str дополнена справа символами fillchar (по умолчанию это пробел ASCII) до указанной длины width.

>>> 'xxx'.ljust(7)
'xxx    '
>>> 
>>> 'xxx'.ljust(7, 'Y')
'xxxYYYY'

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

>>> 'xxx'.ljust(7, 'YZ')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: The fill character must be exactly one character long

Если width < len(str) то указанная строка возвращается без изменений:

>>> 'abcdefgh'.ljust(5)
'abcdefgh'

str.lower([chars])¶: Возвращает новую строку в которой все символы исходной строки преобразованы к нижнему регистру в соответствии с разделом 3.13 стандарта Юникода.

>>> 'XXXYYYZZZ'.lower()
'xxxyyyzzz'
>>> 
>>> 'xXxyYyzZz'.lower()
'xxxyyyzzz'
>>> 
>>> 'xxxyyzzz'.lower()
'xxxyyzzz'

str.lstrip([chars])¶: Возвращает копию исходной строки в которой слева удалены указанные символы (по умолчанию удаляются пробельные символы).

>>> '     xxx'.lstrip()
'xxx'

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

>>> 'xxxyyyzzz'.lstrip('x')
'yyyzzz'
>>> 
>>> 'xxxyyyzzz'.lstrip('xy')
'zzz'
>>> 
>>> 'xxxyyyzzz'.lstrip('xyz')
''

Обратите внимание на то, что последовательность символов в chars не имеет никакого значения. Если какой-то символ в ее составе найден слева в строке str, то он будет удален:

>>> 'xxxyyyzzz'.lstrip('zyx')
''

static str.maketrans(x[, y[, z]])¶: Возвращает таблицу преобразования символов, используемую методом translate(). Содержание строки, относительно которой вызывается метод maketrans() не имеет никакого значения.

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

>>> my_table = ''.maketrans({'a':'1', 'b':'2', 'c':'3'})
>>> 
>>> 'a___b___c'.translate(my_table)
'1___2___3'

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

>>> my_table = ''.maketrans('abc', '123')
>>> 
>>> 'a___b___c'.translate(my_table)
'1___2___3'

Третьим аргументом может быть строка, символы которой изключаются из строки, относительно которой вызван метод translate():

>>> my_table = ''.maketrans('abc', '123', '_#*')
>>> 
>>> 'a_*#*_b_*#*_c'.translate(my_table)
'123'

Данный метод позволяет использовать все экранированные последовательности для работы с символами Юникода: \xhh, \ooo, \N{id}, \uhhhh, \Uhhhhhhhh.

str.partition(sep)¶: Разбивает строку по указанному разделителю и возвращает кортеж из трех элементов: строка до разделителя, сам разделитель и строка после разделителя.

>>> 'xxxxYzzzz'.partition('Y')
('xxxx', 'Y', 'zzzz')

Если разделитель не найден, то возвращается кортеж так же состоящий из трех элементов в котором первый элемент – это исходная строка str, а два других элемента – это пустые строки.

>>> 'xxxxYzzzz'.partition('A')
('xxxxYzzzz', '', '')

str.replace(old, new[, count])¶: Возвращает копию исходной строки в которой все подстроки old заменены на подстроки new. Параметр count позволяет указать количество замен.

>>> s = 'x_aa_x_aa_x_aa_x_aa_x'
>>> 
>>> s.replace('aa', 'bb')
'x_bb_x_bb_x_bb_x_bb_x'

Параметр count позволяет указать необходимое количество замен:

>>> s.replace('aa', 'bb', 1)
'x_bb_x_aa_x_aa_x_aa_x'
>>> 
>>> s.replace('aa', 'bb', 2)
'x_bb_x_bb_x_aa_x_aa_x'
>>> 
>>> s.replace('aa', 'bb', 3)
'x_bb_x_bb_x_bb_x_aa_x'

str.rfind(sub[, start[, end]])¶: Возвращает индекс последнего вхождения подстроки sub в строке str.

>>> s = 'ABC_ABC_ABC_ABC'
>>> 
>>> s.rfind('A')
12
>>> 
>>> s[12]
'A'

Фактически, поиск выполняется внутри среза str[start : end], где start = 0 и end = None, что равносильно поиску по всей строке. Данные параметры интерпретируются как границы среза и могут принимать отрицательные значения:

>>> s.rfind('AB', 3)
12
>>> s.rfind('AB', 3, 11)
8

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

Если не найдено ни одного вхождения то возвращается -1:

>>> s.rfind('AD')
-1

str.rindex(sub[, start[, end]])¶: Выполняет тоже самое, что и метод rfind(), но в случае если не найдено ни одного вхождения подстроки str он вызывает исключение ValueError, а не возвращает -1.

>>> s = 'ABC_ABC_ABC_ABC'
>>> 
>>> s.rfind('AD')
-1
>>> 
>>> s.rindex('AD')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

str.rjust(width[, fillchar])¶: Возвращает новую строку в которой исходная строка дополнена слева указанным в параметре width количеством символов fillchar (по умолчанию – это пробел).

>>> 'xxx'.rjust(5)
'  xxx'
>>> 
>>> 'xxx'.rjust(5, 'Y')
'YYxxx'

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

>>> 'xxx'.rjust(5, 'YZ')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: The fill character must be exactly one character long

Если width < len(str), то будет возвращена исходная строка без изменений:

>>> '123456789'.rjust(5)
'123456789'

str.rpartition(sep)¶: Разбивает строку по последнему встреченному разделителю sep и возвращает кортеж, который состоит из трех элементов: строки до разделителя, самого разделителя и строки после разделителя.

>>> 'aa_x_bb_x_cc_x_dd'.rpartition('_x_')
('aa_x_bb_x_cc', '_x_', 'dd')

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

>>> 'aa_x_bb_x_cc_x_dd'.rpartition('_Y_')
('', '', 'aa_x_bb_x_cc_x_dd')

str.rsplit(sep=None, maxsplit=-1)¶: Аналогичен методу split() с тем лишь отличием, что если параметр maxsplit указан, то разбиение выполняется справа налево.

>>> '1 2 3 4 5 6 7'.rsplit(maxsplit = 3)
['1 2 3 4', '5', '6', '7']
>>> 
>>> '1->2->3->4->5->6'.rsplit('->', maxsplit = 3)
['1->2->3', '4', '5', '6']
>>> 
>>> 
>>> 
>>> '1 2 3 4 5 6 7'.split(maxsplit = 3)
['1', '2', '3', '4 5 6 7']
>>> 
>>> '1 2 3 4 5 6 7'.split(maxsplit = 3)
['1', '2', '3', '4 5 6 7']

str.rstrip([chars])¶: Аналогичен методу lstrip(), но удаление удаление пробелов или указанных символов chars происходит справа а не слева.

>>> '   xxx   '.rstrip()
'   xxx'
>>> 
>>> '   xxx   '.lstrip()
'xxx   '
>>> 
>>> 
>>> 'abcxxxabc'.rstrip('cba')
'abcxxx'
>>> 
>>> 'abcxxxabc'.lstrip('cba')
'xxxabc'

str.split(sep=None, maxsplit=-1)¶: Выполняет разбиение исходной строки на подстроки по символу пробела и возвращает их в виде списка.

>>> '1 2 3 4 5'.split()
['1', '2', '3', '4', '5']

Параметр sep позволяет указать необходимый разделитель:

>>> '1, 2, 3, 4, 5'.split(', ')
['1', '2', '3', '4', '5']
>>> 
>>> '1 -> 2 -> 3 -> 4'.split(' -> ')
['1', '2', '3', '4']

Однако, если параметр sep задан, то следующие друг за другом разделители разделители не воспринимаются как один и считаются разделителями пустых строк:

>>> '1, , , 4, , , 5'.split(', ')
['1', '', '', '4', '', '', '5']
>>> 
>>> '1-->-->4-->-->5'.split('-->')
['1', '', '4', '', '5']
>>> 
>>> 
>>> '1      4      5'.split()    #  а вот пробелы объединяются
['1', '4', '5']

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

>>> '   1   2   3   '.split()
['1', '2', '3']

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

>>> '    '.split()
[]
>>> ''.split()
[]

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

>>> ''.split(',')
['']
>>> ''.split('-->')
['']

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

>>> '1 2 3 4 5'.split(maxsplit = 3)
['1', '2', '3', '4 5']
>>> 
>>> '1->2->3->4->5->6'.split('->', 3)
['1', '2', '3', '4->5->6']

При этом в списке будет присутствовать maxsplit + 1 элементов.

По умолчанию, maxsplit = -1, что соответствует разбиению по всем присутствующим разделителям.

str.splitlines([keepends])¶: Разбивает строку на подстроки по фиксированному набору разделителей и возвращает их в списке.

В отличие от метода split() в котором можно указать произвольный разделитель, в методе splitlines набор разделителей является фиксированным:

\n — перенос строки;
\r — возврат каретки;
\r\n — возврат каретки и перенос строки;
\v or \x0b — вертикальный отступ;
\f or \x0c — разрыв страницы;
\x1c — разделитель файлов;
\x1d — разделитель групп;
\x1e — разделитель строк;
\x85 — следующая строка;
\u2028 — разделитель строк;
\u2029 — разделитель абзацев.

>>> 'A AA\nB BB\rC CC\vD DD'.splitlines()
['A AA', 'B BB', 'C CC', 'D DD']

Обратите внимание на то, что символ пробела не считается разделителем по умолчанию, как в методе split().

Параметр keepends, установленный в значение True (по умолчанию False) позволяет включать разделители в подстроки:

>>> 'A AA\nB BB\rC CC\vD DD'.splitlines(keepends = True)
['A AA\n', 'B BB\r', 'C CC\x0b', 'D DD']

Для пустой строки метод вернет пустой список:

>>> ''.splitlines()
[]

Если в конце строки присутствует всего единственный разделитель, то он просто исключается из нее

>>> 'XXYY\n'.splitlines()
['XXYY']
>>> 'XX\nYY\n'.splitlines()
['XX', 'YY']

Однако, последовательно идущие разделители не объединяются вместе, а считаются разделителями пустых строк

>>> '\n\nXX\n\nYY\n\n'.splitlines()
['', '', 'XX', '', 'YY', '']

str.startswith(prefix[, start[, end]])¶: Возвращает True если строка str начинается с последовательности символов prefix (префикса) и False в противном случае.

>>> 'Есть ли тут префикс???'.startswith('Ес')
True

Параметр prefix может принимать не только один префикс, но и целый кортеж префиксов и если хоть один из них будет найден в начале строки, то мы так же получим True:

>>> 'Есть ли тут префикс???'.startswith(('Ес', 'ту', 'пре'))
True

Параметры strt и end позволяют задать границы среза строки str и могут принимать отрицательные значения:

>>> 'Есть ли тут префикс???'.startswith('ту')
False
>>> 'Есть ли тут префикс???'.startswith('ту', 8)
True
>>> 'Есть ли тут префикс???'.startswith('ту', -14)
True
>>> 'Есть ли тут префикс???'.startswith('ту', 8, 11)
True

str.strip([chars])¶: Возвращает копию исходной строки в начале и конце которой удалены указанные символы chars. Если параметр chars не указан, то по умолчанию удаляются пробельные символы.

>>> 'abc_XXX_abc'.strip('abc')
'_XXX_'

Символы в параметре chars рассматриваются не как последовательность, а как набор символов, которые необходимо удалить:

>>> 'ccbacb_XXX_baacabb'.strip('bca')
'_XXX_'

str.swapcase()¶: Возвращает копию исходной строки в которой все заглавные буквы преобразованы в строчные, строчные – в заглавные.

>>> 'xxxx_YYYY_zzzz'.swapcase()
'XXXX_yyyy_ZZZZ'

В редких случаях, из-за особенностей преобразования к верхнему или нижнему регистру некоторых символов Юникода может произойти так, что str == str.swapcase().swapcase() вернет False:

>>> '\u1e9e'
'ẞ'
>>> 
>>> '\u1e9e'.swapcase()
'ß'
>>> 
>>> '\u1e9e'.swapcase().swapcase()
'SS'
>>> 
>>> '\u1e9e' == '\u1e9e'.swapcase().swapcase()
False

Но, это действительно – редкость.

str.title()¶: Возвращает строку в которой каждое слово исходной строки начинается с буквы в верхнем регистре, а все остальные буквы в нижнем.

>>> 'xxx Yyy zZZ'.title()
'Xxx Yyy Zzz'

Под словом понимается любая последовательность букв разделенная небуквенными символами:

>>> 'xxxx\'x yyyy1y'.title()
"Xxxx'X Yyyy1Y"

Что в некоторых ситуациях может быть не желательным, например:

>>> "let's go".title()
"Let'S Go"

В таких ситуациях лучше всего воспользоваться модулем re.

str.translate(table)¶: Преобразует символы исходной строки в соответствии с правилами преобразования в объекте table.

Проще всего данный метод использовать в связке с методом str.maketrans(), позволяющим быстро задать таблицу преобразований:

>>> my_table = ''.maketrans('abc', '123', '_#*')
>>> 
>>> 'a_*#*_b_*#*_c'.translate(my_table)
'123'

str.upper()¶: Возвращает новую строку в которой каждый символ строки str находится в верхнем регистре.

>>> 'abcdtfg'.upper()
'ABCDTFG'
>>> 
>>> 'AbCdEfG'.upper()
'ABCDEFG'

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

>>> 'a1cf2d'.upper()
'A1CF2D'
>>> 
>>> 'Что?!!'.upper()
'ЧТО?!!'

Как правило, с этим преобразованием, не связано никаких проблем, но следует иметь в виду, что в очень редких случаях символы могут быть преобразованы не к верхнему регистру (категория "Lu"), а к прописным (категория "Lt"). Поэтому метод isupper() может выдавать False, когда от него ожидается True. Если вы все-таки с этим столкнулись, то смотрите документацию по преобразованию к верхнему регистру на официальном сайте Юникода.

str.zfill(width)¶: Возвращает новую строку, в которой исходная строка str дополнена нулями слева, так что бы длина новой строки стала равна width.

>>> ''.zfill(7)
'0000000'
>>> 
>>> '3.14'.zfill(6)
'003.14'
>>> 
>>> 'a12f'.zfill(8)
'0000a12f'

Обратите внимание на то, что в параметре width указывается не количество нулей, а именно длина результирующей строки, если width < len(str), тоисходная строка str возвращается без изменений:

>>> '3.14'.zfill(2)
'3.14'
>>> 
>>> len('3.14'.zfill(20))    #  width указывает необходимую длину строки
20

Знаки "+" и "-" всегда располагаются в начале строки и учитываются при расчете длины:

>>> '+a12f'.zfill(8)
'+000a12f'
>>> 
>>> '-a12f'.zfill(8)
'-000a12f'
>>> 
>>> len('-a12f'.zfill(8))
8