Методы строк
Строковые методы в языке Python помогают решать целый ряд самых распространенных задач.
- 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
>>> 'всем привет!'.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