Python3, строки и их методы

avm

Опубликован:  2018-02-15T05:44:36.517350Z
Отредактирован:  2018-02-15T05:35:16.545248Z
5701
Список содержит обзор одного из встроенных типов Python3 - строк, а так же справочную информацию и примеры использования для каждого из имеющихся в арсенале этого типа объектов методов. Спойлеры ниже кликабельны. Вопросы и замечания приветствуются в комментариях.

1. Краткий обзор

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

Строка - последовательность символов ограниченная одинарными или двойными кавычками. Строки используются для представления текстовых данных и выполнения различных манипуляций с ними. В Питоне третьей версии строки определяются классом str модуля стандартной библиотеки builtins.

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

>>> s = 'Hello, World!'
>>> isinstance(s, str)
True
>>> type(s)
<class 'str'>
>>> 

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

>>> good = "This is a good string"
>>> good = 'This is a good string too'
>>> bad = 'This string is not good"
  File "<stdin>", line 1
    bad = 'This string is not good"
                                  ^
SyntaxError: EOL while scanning string literal
>>> 

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

>>> "This string" == 'This string'
True
>>> 

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

>>> good = "It's wonderful!"
>>> good = 'It\'s wonderful!'
>>> good = '"Good way", "Bad way"'
>>> 

Unicode-строки в Python3 ничем не отличаются от ascii-строк:

>>> s = 'Здравствуй, мир!'
>>> isinstance(s, str)
True
>>> type(s)
<class 'str'>
>>> 

Строки могут содержать escape-последовательности.

escape-sequences

При печати таких строк escape-последовательности обрабатываются соответствующим образом.

>>> s = 'abnormal\normal\negative\notfound'
>>> print(s)
abnormal
ormal
egative
otfound
>>> 

Предотвратить обработку escape-последовательностей при печати позволяют так называемые raw-строки.

>>> s = r'abnormal\normal\negative\notfound'
>>> print(s)
abnormal\normal\negative\notfound
>>> 

Символ r перед открывающей строку кавычкой в данном случае означает, что в этой строке все escape-последовательности будут автоматически экранированы символом обратного слэша.

>>> s = r'\total\normal\\\'\b'
>>> s
"\\total\\normal\\\\\\'\\b"
>>> print(s)
\total\normal\\\'\b
>>> 

Питон позволяет создавать пустые строки, пустые строки не содержат символов.

>>> s = str()
>>> b = ''
>>> s == b
True
>>> 

Единственная особенность пустой строки заключается в булевой операции. Булева операция над пустой строкой возвращает False, в то время, как булева операция над строкой содержащей хоть один символ возвращает True.

>>> empty = ''
>>> full = 'o'
>>> bool(empty)
False
>>> bool(full)
True
>>> 

Откуда берутся строки? Вполне резонный вопрос. Путей достаточное количество. Строки можно получать из пользовательского ввода.

>>> s = input('Введите целое число: ')
Введите целое число: 453
>>> s
'453'
>>> type(s)
<class 'str'>
>>> 

Строки можно импортировать из других модулей.

>>> from string import digits
>>> type(digits)
<class 'str'>
>>> digits
'0123456789'
>>> 

Строки можно получать из текстовых файлов.

>>> ef = open('test.txt')
>>> s = ef.read()
>>> ef.close()
>>> s
'Hello, World!\n'
>>> type(s)
<class 'str'>
>>> 

В строки можно преобразовывать другие типы данных.

>>> n = 34231
>>> s = str(n)
>>> s
'34231'
>>> 

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

>>> s = 'sad'
>>> s[1] = 'i'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> 

Вторая характерная особенность строк - любая строка является итерируемым объектом.

>>> s = 'Hello, World!\n'
>>> for i in s:
...     print(i, end=' ')
... 
H e l l o ,   W o r l d ! 
 >>> 

Третья характерная особенность строк - строка имеет длину. Длину строки можно определить при помощи встроенной функции len.

>>> s = 'Определяем длину строки'
>>> len(s)
23
>>> 

Длина строки - это целое число, отражающее количество символов в строке.

К каждому символу строки можно получить доступ по индексу.

>>> s[0]    # первый символ строки
'О'
>>> s[1]    # второй символ строки
'п'
>>> s[-1]    # последний символ строки
'и'
>>> 

Здесь следует отметить, что в выражении s[n] число n должно быть меньше длины строки.

>>> s
'Определяем длину строки'
>>> len(s)
23
>>> s[22] == s[-1]
True
>>> s[23]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> 

По отрицательному индексу можно получить доступ к символам строки начиная с конца строки.

>>> s
'Определяем длину строки'
>>> s[-1]
'и'
>>> s[-2]
'к'
>>> s[-23]
'О'
>>> 

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

>>> s
'Определяем длину строки'
>>> s[0:10]
'Определяем'
>>> 

Первый и второй индексы в срезе можно опускать.

>>> s[:10]
'Определяем'
>>> s[11:]
'длину строки'
>>> 

В срезе можно определять интервал.

>>> s[:11:2]
'Ордле '
>>> 

При помощи среза строку можно достаточно легко инвертировать.

>>> s
'Определяем длину строки'
>>> s[::-1]
'икортс унилд меяледерпО'
>>> 

В приведённых выше примерах операций со строками можно выделить булевы операции над строками, то есть две строки можно сравнивать.

>>> 'Hello' == 'hello'
False
>>> 'Hello' > 'hello'
False
>>> 'hello' > 'Hello'
True
>>> 

Строки можно складывать. Такую операцию принято называть конкатенацией.

>>> s = 'Hello, '
>>> v = 'World!'
>>> a = s + v
>>> a
'Hello, World!'
>>> 

Строки можно умножать на целые числа.

>>> s = 'три '
>>> v = s * 5
>>> v
'три три три три три '
>>> 

Таким образом можно составлять целые выражения.

>>> s = 'три, '
>>> v = 'будет дырка'
>>> result = s * 5 + v
>>> result
'три, три, три, три, три, будет дырка'
>>> 

Кроме того, класс str определяет довольно обширный набор методов, при помощи которых можно сравнительно просто и без затрат производить над строками достаточно сложные манипуляции. Список доступных методов для строк можно получить при помощи встроенной функции dir. Допустим у нас есть строка s.

>>> s = 'Hello, World!'
>>> 

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

>>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> 

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

Резюмируя, хочу отметить, что строки в Питоне используются очень широко и повсеместно. Можно смело утверждать, что без строк не обходится практически ни одна программа написанная на Питоне. Поэтому важно понимать их назначение и функции, уметь с ними работать и знать, где и как можно получить о них справочную информацию.

2. capitalize

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

>>> s = 'hELLO, WORLD!'
>>> s.capitalize()
'Hello, world!'
>>> m = 'hello, World!'
>>> m.capitalize()
'Hello, world!'
>>> 

Исходная строка при этом остаётся неизменной.

>>> s = 'hello, World!'
>>> s.capitalize()
'Hello, world!'
>>> s
'hello, World!'
>>> 

Применение этого метода обосновано только если исходная строка состоит из букв. Если в исходной строке буквы отсутствуют, возвращаемая строка будет эквивалентна исходной.

>>> n = '12345'
>>> n.capitalize() == n
True
>>> n.capitalize()
'12345'
>>> 

3. casefold

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

>>> s = 'hello, WORLD!'
>>> s.casefold()
'hello, world!'
>>> 

Исходная строка при этом остаётся неизменной.

>>> name = 'Жириновский Владимир Вольфович'
>>> name.casefold()
'жириновский владимир вольфович'
>>> name
'Жириновский Владимир Вольфович'
>>> 

4. center

Метод center возвращает строку, которая содержит в себе исходную строку и выравнивает её по центру. Метод принимает обязательный аргумент width, определяющий длину возвращаемой строки. Имеет смысл, когда задаётся длина новой строки (первый аргумент метода) больше длины исходной строки.

>>> s = 'EXIT'
>>> s.center(6)
' EXIT '
>>> s.center(12)
'    EXIT    '
>>> 

По умолчанию выравнивание осуществляется пробелами, но можно определить другой символ для заполнения.

>>> s = 'EXIT'
>>> s.center(12, '+')
'++++EXIT++++'
>>> s.center(10, '=')
'===EXIT==='
>>> 

Исходная строка при этом остаётся неизменной.

>>> n = 'help me, please'
>>> len(n)
15
>>> n.center(25, '*')
'*****help me, please*****'
>>> n
'help me, please'
>>> 

5. count

Метод count считает число вхождений в исходную строку подстроки заданной первым аргументом метода и возвращает это число.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.count('l')
8
>>> 

При помощи аргументов можно ограничить фрагмент исходной строки, в котором будет посчитано количество вхождений заданной подстроки. Например, считаем количество вхождений с 6-ого символа исходной строки.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.count('l', 6)
6
>>> s[6:]
'lamo, limo, lol and boll'

А теперь начиная с восьмого и заканчивая двадцать пятым.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.count('l', 8, 25)
3
>>> s[8:25]
'mo, limo, lol and'
>>> 

Аргументы начала и конца фрагмента интерпретируются аналогично срезу строки.

6. encode

Метод encode принимает два аргумента:

  • encoding - задаёт кодировку, по умолчанию имеет значение utf-8;
  • errors - определяет, каким образом будут обрабатываться ошибки, по умолчанию имеет значение strict, что значит, что при возникновении ошибки будет генерироваться исключение, может принимать значения: strict, ignore, replace и xmlcharrefreplace.

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

>>> s = 'Здравствуй, мир!'
>>> s.encode()
b'\xd0\x97\xd0\xb4\xd1\x80\xd0\xb0\xd0\xb2\xd1\x81\xd1\x82\xd0\xb2\xd1\x83\xd0\xb9, \xd0\xbc\xd0\xb8\xd1\x80!'
>>> 

Следует заметить, что исходная строка при этом остаётся неизменной. При необходимости можно задать другую кодировку.

>>> s = 'Здравствуй, мир!'
>>> s.encode('cp1251')
b'\xc7\xe4\xf0\xe0\xe2\xf1\xf2\xe2\xf3\xe9, \xec\xe8\xf0!'
>>> 

Как видно из примеров, при помощи этого метода можно осуществить преобразование типов - строки в байты с заданной кодировкой.

>>> s = 'Здравствуй, мир!'
>>> type(s.encode('cp1251'))
<class 'bytes'>
>>> 

Список поддерживаемых кодировок и их алиасы можно найти в модуле encodings.

>>> import encodings
>>> for key in encodings.aliases.aliases:
...     if key == 'utf8':
...        print('{} -> {}'.format(key, encodings.aliases.aliases[key]))
... 
utf8 -> utf_8
>>> 

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

>>> s = 'Здравствуй, мир!'
>>> s.encode('cp1252')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python3.5/encodings/cp1252.py", line 12, in encode
    return codecs.charmap_encode(input,errors,encoding_table)
UnicodeEncodeError: 'charmap' codec can't encode characters in position 0-9: character maps to <undefined>
>>>

Метод позволяет обойти подобный исход ценой потери данных.

>>> s.encode('cp1252', errors='replace')
b'??????????, ???!'
>>> 

7. endswith

Метод endswith проверяет, заканчивается ли исходная строка заданным суффиксом - подстрокой заданной в первом аргументе метода, и возвращает булево значение True или False в зависимости от результата проверки.

>>> s = 'Hello, World!'
>>> s.endswith('!')
True
>>> s.endswith('?')
False
>>> 

При помощи аргументов start и end метод позволяет определить фрагмент исходной строки в пределах которого осуществляется проверка.

>>> s = 'Hello, World!'
>>> s.endswith('!', 11, 12)
False
>>> s.endswith('!', 11, 13)
True
>>>

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

>>> s = 'Hello, World!'
>>> s.endswith(('.', '!', '?'))
True
>>> s.endswith(('.', ',', '?'))
False
>>> 

8. expandtabs

Метод expandtabs возвращает копию исходной строки, в которой табуляции преобразованы в пробелы.

>>> s = '\t123'
>>> s.expandtabs()
'        123'
>>> 

Ширина табуляции заданная по умолчанию равна 8-ми пробелам, можно задать своё значение.

>>> s.expandtabs(tabsize=5)
'     123'
>>> 

9. find

Метод find находит в исходной строке заданную подстроку и возвращает наименьший индекс (int), в котором найдена заданная подстрока.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.find('l')
2
>>> s.find('o,')
9
>>> 

Если исходная строка не содержит заданную подстроку, метод возвращает значение -1 (int).

>>> s = 'hello lamo, limo, lol and boll'
>>> s.find('wow')
-1
>>> 

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

>>> s = 'hello lamo, limo, lol and boll'
>>> s.find('l', 5, 9)
6
>>> s.find('l', 7, 9)
-1
>>> 

10. format

Метод format использует исходную строку как шаблон, подставляет в этот шаблон свои аргументы на места ограниченные фигурными скобками и возвращает получившуюся строку.

>>> 'Расстояние до точки - {0} км.'.format(365)
'Расстояние до точки - 365 км.'
>>> 

Один из множества возможных примеров использования этого метода можно посмотреть в Python3, решаем простые задачи. Метод format имеет достаточно широкие возможности, описание которых не укладывается в формат данного документа. Возможно в перспективе я посвящу ему отдельную тему.

11. format_map

Метод format_map сходен с методом format и выполняет аналогичные действия, при этом процедура форматирования строки несколько отличается.

>>> values = {'min': 25,
...           'sec': 58,
...           'fr': 43}
>>> '{min}:{sec}:{fr}'.format_map(values)
'25:58:43'
>>> 

12. index

Метод index аналогичен методу find. Отличие заключается в том, что если исходная строка не содержит заданную подстроку, генерируется исключение (ValueError).

>>> s = 'hello lamo, limo, lol and boll'
>>> s.index('l')
2
>>> s.index('o,')
9
>>> s.index('w')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> 

13. isalnum

Метод isalnum возвращает булево значение True, если все символы исходной строки являются буквами или цифрами, и в исходной строке есть хоть один символ.

>>> s = 'abs123'
>>> s.isalnum()
True
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = ''
>>> s.isalnum()
False
>>> s = 'abs123.'
>>> s.isalnum()
False
>>> 

14. isalpha

Метод isalpha возвращает булево значение True, если все символы исходной строки являются буквами алфавита, и в исходной строке есть хоть один символ.

>>> s = 'abcdfABCDF'
>>> s.isalpha()
True
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = 'abc123'
>>> s.isalpha()
False
>>> s = ''
>>> s.isalpha()
False
>>> s = 'abc.'
>>> s.isalpha()
False
>>> 

15. isdecimal

Метод isdecimal возвращает булево значение True, если все символы исходной строки являются цифрами десятичной системы исчисления, и в исходной строке есть хоть один символ.

>>> from string import digits
>>> digits.isdecimal()
True
>>> digits
'0123456789'
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = '123.34'
>>> s.isdecimal()
False
>>> s = ''
>>> s.isdecimal()
False
>>> s = 'abc.123'
>>> s.isdecimal()
False
>>> 

16. isdigit

Метод isdigit аналогичен методу isdecimal.

>>> from string import digits
>>> digits
'0123456789'
>>> digits.isdigit()
True
>>> s = ' 123'
>>> s.isdigit()
False
>>> s = ''
>>> s.isdigit()
False
>>> 

17. isidentifier

Метод isidentifier возвращает булево значение True если исходная строка может быть идентификатором в соответствии с определением языка.

>>> s = 'x'
>>> s.isidentifier()
True
>>> 

Во всех остальных случая этот метод вернёт булево значение False.

>>> s = '-x'
>>> s.isidentifier()
False
>>> s = ''
>>> s.isidentifier()
False
>>> s = '123hello'
>>> s.isidentifier()
False
>>> 

18. islower

Метод islower возвращает булево значение True, если в исходной строке отсутствуют заглавные буквы алфавита, и исходная строка содержит хоть один символ алфавита.

>>> s = 'hello, world!'
>>> s.islower()
True
>>> 

В противном случае этот метод вернёт булево значение False.

>>> s = 'Hello, World!'
>>> s.islower()
False
>>> s = 'hello, World!'
>>> s.islower()
False
>>> s = ''
>>> s.islower()
False
>>> s = '123'
>>> s.islower()
False
>>> 

19. isnumeric

Метод isnumeric аналогичен методу isdecimal.

>>> from string import digits
>>> digits.isnumeric()
True
>>> digits
'0123456789'
>>> s = ' 123'
>>> s.isnumeric()
False
>>> s = ''
>>> s.isnumeric()
False
>>> 

20. isprintable

Метод isprintable возвращает булево значение True, если все символы исходной строки являются печатными символами, или если в исходной строке отсутствуют символы (пустая строка).

>>> s = 'hello, world!'
>>> s.isprintable()
True
>>> s = ''
>>> s.isprintable()
True
>>> 

В иных случаях этот метод вернёт булево значение False.

>>> s = 'hello, world!\n'
>>> s.isprintable()
False
>>> s = chr(7)
>>> type(s)
<class 'str'>
>>> s.isprintable()
False
>>> 

21. isspace

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

>>> from string import whitespace
>>> whitespace
' \t\n\r\x0b\x0c'
>>> whitespace.isspace()
True
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = ''
>>> s.isspace()
False
>>> s = 'hello, world!'
>>> s.isspace()
False
>>> s = chr(7)
>>> s.isspace()
False
>>> 

22. istitle

Метод istitle возвращает булево значение True, если каждое слово в исходной строке начинается с заглавной буквы, а все остальные буквы в слове - строчные, и в исходной строке есть хоть один символ.

>>> s = 'Я Не Знаю Зачем Это Нужно.'
>>> s.istitle()
True
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = 'Я не Знаю зачем это нужно.'
>>> s.istitle()
False
>>> s = ''
>>> s.istitle()
False
>>> s = 'Я не знаю зачем это нужно.'
>>> s.istitle()
False
>>> 

23. isupper

Метод isupper возвращает булево значение True, если все символы исходной строки являются заглавными буквами, и в исходной строке есть хоть один символ, соответствующий этому условию.

>>> from string import ascii_uppercase as s
>>> s
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> s.isupper()
True
>>> s = 'HELLO, WORLD!'
>>> s.isupper()
True
>>> 

Во всех остальных случаях этот метод вернёт булево значение False.

>>> s = ''
>>> s.isupper()
False
>>> s = 'abcd'
>>> s.isupper()
False
>>> s = '123'
>>> s.isupper()
False
>>> s = 'Hello, World!'
>>> s.isupper()
False
>>> 

24. join

Метод join принимает в качестве аргумента любое итерируемое значение, все элементы которого являются строками. Метод склеивает все элементы итерируемого значения с исходной строкой в качестве разделителя и возвращает склеенную строку.

>>> iterable = ['hello,', 'world']
>>> ' '.join(iterable)
'hello, world'
>>> 

В качестве аргумента может выступать выражение, возвращающее итерируемое значение.

>>> '.'.join(str(i) for i in range(10))
'0.1.2.3.4.5.6.7.8.9'
>>> 

25. ljust

Метод ljust возвращает выровненную пробелами по левому краю исходную строку. Имеет смысл, если заданная длина выровненной строки больше длины исходной строки. Длина выровненной строки задаётся первым аргументом этого метода.

>>> s = 'hello'
>>> s.ljust(11)
'hello      '
>>> 

Для выравнивания вместо пробелов можно задать любой другой символ.

>>> s.ljust(14, '_')
'hello_________'
>>> s.ljust(10, '%')
'hello%%%%%'
>>> 

26. lower

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

>>> s = 'Hello, World!'
>>> s.lower()
'hello, world!'
>>> 

27. lstrip

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

>>> s = '\nHello, World!'
>>> s.lstrip()
'Hello, World!'
>>> s = '\r\n  Hello, World!'
>>> s.lstrip()
'Hello, World!'
>>> 

Метод lstrip позволяет указать, какие символы исходной строки следует удалить в возвращаемой копии. Удаляются только указанные символы, находящиеся слева.

>>> s = '---hello---'
>>> s.lstrip('-')
'hello---'
>>> 

28. partition

Метод partition принимает в качестве аргумента заданную подстроку, возвращает первую часть исходной строки, которая находится до заданной подстроки, затем заданную подстроку, затем часть строки, которая находится за заданной подстрокой.

>>> s = 'hello, world!'
>>> s.partition(',')
('hello', ',', ' world!')
>>> 

Если заданная подстрока в исходной строке не найдена, то метод вернёт тюпл с исходной строкой и двумя пустыми строками.

>>> s = 'hello world!'
>>> s.partition(',')
('hello world!', '', '')
>>> 

Метод partition находит только первую слева заданную подстроку в исходной строке.

>>> s = 'hello, again, and agian, stop.'
>>> s.partition(',')
('hello', ',', ' again, and agian, stop.')
>>> 

29. replace

Метод replace принимает два обязательных аргумента:

  • old,
  • new.

Метод возвращает копию исходной строки, в которой все символы заданные в old заменяются символами заданными в new.

>>> s = 'this_is_an_interesting_idea'
>>> s.replace('_', ' ')
'this is an interesting idea'
>>> s.replace('_', '-')
'this-is-an-interesting-idea'
>>> 

При необходимости можно задать количество символов, подлежащих замене.

>>> s.replace('_', '-', 3)
'this-is-an-interesting_idea'
>>> 

Отсчёт и замена символов производится слева.

30. rfind

Метод rfind ищет в исходной строке заданную подстроку и возвращает наибольший индекс исходной строки, в котором размещена заданная подстрока.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.rfind('l')
29
>>> 

Если исходная строка не содержит заданную подстроку, метод вернёт минус единицу.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.rfind('w')
-1
>>> 

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

>>> s = 'hello lamo, limo, lol and boll'
>>> s.rfind('o', 3, 11)
9
>>> 

31. rindex

Метод rdindex аналогичен методу rfind, отличие заключается лишь в том, что если исходная строка не содержит заданную подстроку, то генерируется исключение.

>>> s = 'hello lamo, limo, lol and boll'
>>> s.rindex('w')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> 

32. rjust

Метод rjust аналогичен методам ljust и center с той лишь разницей, что в возвращаемой строке исходная строка выравнивается по правому краю.

>>> s = 'hello'
>>> s.rjust(10)
'     hello'
>>> s.rjust(14, '_')
'_________hello'
>>> s.rjust(7, '+')
'++hello'
>>> 

Метод имеет смысл, только если заданная длина возвращаемой строки больше длины исходной строки.

33. rpartition

Метод rpartition аналогичен методу partition с той лишь разницей, что поиск заданного разделителя осуществляется с конца исходной строки.

>>> s = 'hello, world!'
>>> s.rpartition(',')
('hello', ',', ' world!')
>>> s = 'hello world!'
>>> s.rpartition(',')
('', '', 'hello world!')
>>> s = 'hello, again, and again, stop.'
>>> s.rpartition(',')
('hello, again, and again', ',', ' stop.')
>>> 

34. rsplit

Метод rsplit принимает два опциональных аргумента:

  • sep - строка разделитель, по умолчанию имеет значение None;
  • maxsplit - количество совершаемых делений по разделителю, по умолчанию имеет значение -1.

Метод rsplit возвращает список состоящий из строк, полученных в результате деления исходной строки по заданной строке разделителю. Деление осуществляется с конца строки, количество делений в соответствии со значением заданным maxsplit. Если строка разделитель не задана, то деление осуществляется по пробелу. Если maxsplit не задан, то деление осуществляется по каждому разделителю найденому в исходной строке.

>> s.rsplit()
['hello', 'world', 'I', 'am', 'here']
>>> 

Важное замечание: деление осуществляется с конца строки.

>>> s = 'hello world I am here'
>>> s.rsplit(maxsplit=3)
['hello world', 'I', 'am', 'here']
>>> 

Строка разделитель может быть задана группой символов.

>>> s = 'hello world I am here and I say hello'
>>> s.rsplit(sep='hello')
['', ' world I am here and I say ', '']
>>> 

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

>>> s = 'hello world I am here and I say hello'
>>> s.rsplit(sep='t')
['hello world I am here and I say hello']
>>> 

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

35. rstrip

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

>>> s = 'Hello, World!\n'
>>> s.rstrip()
'Hello, World!'
>>> s = 'Hello, World! \r\n'
>>> s.rstrip()
'Hello, World!'
>>> 

Метод rstrip позволяет указать, какие символы исходной строки следует удалить в возвращаемой копии. Удаляются только указанные символы, находящиеся справа.

>>> s = '---hello---'
>>> s.rstrip('-')
'---hello'
>>> 

36. split

Метод split аналогичен методу rsplit и принимает те же самые аргументы с той лишь разницей, что этим методом деление осуществляется с начала строки.

>>> s = 'hello world I am here'
>>> s.split()
['hello', 'world', 'I', 'am', 'here']
>>> s.split(maxsplit=3)
['hello', 'world', 'I', 'am here']
>>> 

37. splitlines

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

>>> s = 'hello, world.\r\nI am here.\r\nAnd I say hello.'
>>> s.splitlines()
['hello, world.', 'I am here.', 'And I say hello.']
>>> 

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

>>> s = 'hello, world.\r\nI am here.\r\nAnd I say hello.'
>>> s.splitlines(True)
['hello, world.\r\n', 'I am here.\r\n', 'And I say hello.']
>>> 

38. startswith

Метод startswith проверяет, начинается ли исходная строка заданным префиксом - подстрокой заданной в первом аргументе метода, и возвращает булево значение True или False в зависимости от результата проверки.

>>> s = 'Hello, World!'
>>> s.startswith('H')
True
>>> s.startswith('h')
False
>>> 

При помощи аргументов start и end метод позволяет определить фрагмент исходной строки в пределах которого осуществляется проверка.

>>> s = 'Hello, World!'
>>> s.startswith('l', 1, -1)
False
>>> s.startswith('l', 2, -1)
True
>>> 

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

>>> s = 'Hello, World!'
>>> s.startswith(('h', 'H'))
True
>>> s.startswith(('h', 'b'))
False
>>> 

39. strip

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

>>> s = '\r\n    Hello, World!    \r\n'
>>> s.strip()
'Hello, World!'
>>> 

Аналогично методам lstrip и rstrip, метод strip позволяет указать, какие символы следует удалить в возвращаемой копии. Удаляются только указанные символы, находящиеся в начале и конце исходной строки.

>>> s = '---Hello-World!---'
>>> s.strip('-')
'Hello-World!'
>>> 

40. swapcase

Метод swapcase возвращает копию исходной строки, в которой заглавные буквы будут конвертированы в строчные, а строчные буквы будут конвертированы в заглавные.

>>> s = 'Hello, World!'
>>> s.swapcase()
'hELLO, wORLD!'
>>> 

41. title

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

>>> s = 'HELLO, WORLD!'
>>> s.title()
'Hello, World!'
>>> s = 'hello, world!'
>>> s.title()
'Hello, World!'
>>> 

42. upper

Метод upper возвращает копию исходной строки, в которой все символы преобразованы в верхний регистр.

>>> s = 'hello, world!'
>>> s.upper()
'HELLO, WORLD!'
>>> 

43. zfill

Метод zfill принимает один обязательный аргумент - width - определяющий заданную ширину поля. Метод zfill возвращает копию исходной строки заданной ширины заполненную нулями слева, обычно применяется для строк с числовыми последовательностями.

>>> s = '32'
>>> s.zfill(8)
'00000032'
>>> len(s)
2
>>> len(s.zfill(8))
8
>>> 

Если заданная ширина поля равна длине исходной строки, метод возвращает копию исходной строки.

>>> s = '32'
>>> s.zfill(2)
'32'
>>> 

44. translate и maketrans

Метод translate возвращает копию исходной строки, в которой все символы заменены в соответствии с таблицей перевода. Таблицу перевода для метода translate можно получить при помощи метода maketrans. Для демонстрации работы метода translate предлагаю пример перевода русскоязычной кириллической строки в транслитерацию. Для этого мне понадобится заранее приготовленный словарь, в котором каждому кириллическому символу соответствуют символы замены.

>>> pprint(table)
{'Ё': 'E',
 'А': 'A',
 'Б': 'B',
 'В': 'V',
 'Г': 'G',
 'Д': 'D',
 'Е': 'E',
 'Ж': 'Zh',
 'З': 'Z',
 'И': 'I',
 'Й': 'I',
 'К': 'K',
 'Л': 'L',
 'М': 'M',
 'Н': 'N',
 'О': 'O',
 'П': 'P',
 'Р': 'R',
 'С': 'S',
 'Т': 'T',
 'У': 'U',
 'Ф': 'F',
 'Х': 'Kh',
 'Ц': 'Ts',
 'Ч': 'Ch',
 'Ш': 'Sh',
 'Щ': 'Shch',
 'Ъ': '',
 'Ы': 'Y',
 'Ь': '',
 'Э': 'E',
 'Ю': 'Iu',
 'Я': 'Ia',
 'а': 'a',
 'б': 'b',
 'в': 'v',
 'г': 'g',
 'д': 'd',
 'е': 'e',
 'ж': 'zh',
 'з': 'z',
 'и': 'i',
 'й': 'i',
 'к': 'k',
 'л': 'l',
 'м': 'm',
 'н': 'n',
 'о': 'o',
 'п': 'p',
 'р': 'r',
 'с': 's',
 'т': 't',
 'у': 'u',
 'ф': 'f',
 'х': 'kh',
 'ц': 'ts',
 'ч': 'ch',
 'ш': 'sh',
 'щ': 'shch',
 'ъ': '',
 'ы': 'y',
 'ь': '',
 'э': 'e',
 'ю': 'iu',
 'я': 'ia',
 'ё': 'e'}
>>> 

Задаю исходную строку и преобразую её в транслитерацию.

>>> s = 'Клуб любителей рептилий и хищников.'
>>> s.translate(str.maketrans(table))
'Klub liubitelei reptilii i khishchnikov.'
>>> 
 
Осталось: 121
Комментарии: