string — Общие операции со строками

Исходный код: Lib/string.py

Модуль string содержит ряд полезных констант и классов, а также некоторые устаревшие функции, которые также доступны как методы строк. Кроме того, встроенные строковые классы Python поддерживают методы типа последовательности, описанные в разделе Типы последовательностей — str, unicode, list, tuple, bytearray, buffer, xrange, а также специфические методы строк, описанные в разделе Методы строк. Для вывода форматированных строк используйте шаблоны строк или оператор %, описанный в разделе Операции форматирования строк. Также см. модуль re для функций работы со строками, основанных на регулярных выражениях.

1. Константы строк

Определённые в этом модуле константы:

string.ascii_letters

Конкатенация констант ascii_lowercase и ascii_uppercase, описанных ниже. Это значение не зависит от локали.

string.ascii_lowercase

Строчные буквы 'abcdefghijklmnopqrstuvwxyz'. Это значение не зависит от локали и не изменится.

string.ascii_uppercase

Прописные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Это значение не зависит от локали и не изменится.

string.digits

Строка '0123456789'.

string.hexdigits

Строка '0123456789abcdefABCDEF'.

string.letters

Конкатенация строк lowercase и uppercase, описанных ниже. Конкретное значение зависит от локали и будет обновляться при вызове locale.setlocale().

string.lowercase

Строка, содержащая все символы, считающиеся строчными буквами. На большинстве систем это строка 'abcdefghijklmnopqrstuvwxyz'. Конкретное значение зависит от локали и будет обновляться при вызове locale.setlocale().

string.octdigits

Строка '01234567'.

string.punctuation

Строка ASCII-символов, которые считаются знаками препинания в локали C.

string.printable

Строка символов, которые считаются печатными. Это комбинация digits, letters, punctuation и whitespace.

string.uppercase

Строка, содержащая все символы, считающиеся прописными буквами. На большинстве систем это строка 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Конкретное значение зависит от локали и будет обновляться при вызове locale.setlocale().

string.whitespace

Строка, содержащая все символы, считающиеся пробелами. На большинстве систем это пробел, табуляция, перевод строки, возврат каретки, разделитель страницы и вертикальная табуляция.

2. Настраиваемое форматирование строк

Встроенные классы str и unicode предоставляют возможность выполнять сложные подстановки переменных и форматирование значений через метод str.format(), описанный в PEP 3101. Класс Formatter в модуле string позволяет создавать и настраивать собственные поведения форматирования строк, используя ту же реализацию, что и встроенный метод format().

class string.Formatter

Класс Formatter имеет следующие публичные методы:

format(format_string, *args, **kwargs)

Основной метод API. Он принимает строку формата и произвольный набор позиционных и именованных аргументов. Это просто обертка, которая вызывает vformat().

vformat(format_string, args, kwargs)

Эта функция выполняет фактическую работу по форматированию. Она предоставляется как отдельная функция для случаев, когда вы хотите передать предварительно определённый словарь аргументов, а не распаковывать и упаковывать словарь как отдельные аргументы, используя синтаксис *args и **kwargs. vformat() выполняет работу по разделению строки формата на символьные данные и поля замены.

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

Кроме того, класс Formatter определяет ряд методов, предназначенных для замены подклассами:

parse(format_string)

Проходит по строке формата и возвращает итерируемый объект кортежей (literal_text, field_name, format_spec, conversion). Это используется vformat() для разделения строки на литеральные тексты или поля замены.

Значения в кортеже концептуально представляют собой диапазон литерального текста, за которым следует одно поле замены. Если литерального текста нет (что может произойти, если два поля замены находятся рядом), то literal_text будет строкой длиной 0. Если нет поля замены, то значения field_name, format_spec и conversion будут None.

get_field(field_name, args, kwargs)

Учитывая field_name, возвращённое методом parse() (см. выше), преобразует его в объект для форматирования. Возвращает кортеж (obj, used_key). Стандартная версия принимает строки в формате, определённом в PEP 3101, таких как “0[name]” или “label.title”. args и kwargs передаются в vformat(). Возвращаемое значение used_key имеет такое же значение, что и параметр key метода get_value().

get_value(key, args, kwargs)

Получение значения заданного поля. Параметр key будет либо целым числом, либо строкой. Если это целое число, оно представляет индекс позиционного аргумента в args; если это строка, то она представляет именованный аргумент в kwargs.

Параметр args задаётся списком позиционных аргументов для vformat(), а параметр kwargs задаётся словарем именованных аргументов.

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

Например, выражение поля ‘0.name’ заставит метод get_value() быть вызванным с аргументом key равным 0. Атрибут name будет найден после того, как get_value() вернёт результат вызова встроенной функции getattr().

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

check_unused_args(used_args, args, kwargs)

Реализует проверку на неиспользуемые аргументы, если это необходимо. Аргументами этой функции является множество всех ключей аргументов, которые фактически использовались в строке формата (целые числа для позиционных аргументов и строки для именованных аргументов), и ссылка на args и kwargs, которые были переданы в vformat. Множество неиспользуемых аргументов может быть вычислено из этих параметров. Метод check_unused_args() предполагается, что он поднимает исключение, если проверка не пройдена.

format_field(value, format_spec)

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

convert_field(value, conversion)

Преобразует значение (возвращённое get_field()) с учётом типа преобразования (как в кортеже, возвращённом методом parse()). Стандартная версия понимает типы преобразования ‘s’ (str), ‘r’ (repr) и ‘a’ (ascii).

3. Синтаксис строк формата

Метод str.format() и класс Formatter используют один и тот же синтаксис для строк формата (хотя в случае с Formatter, подклассы могут определять свой собственный синтаксис строк формата).

Строки формата содержат «поля замены», заключённые в фигурные скобки {}. Всё, что не содержится в фигурных скобках, считается литеральным текстом, который копируется в выходные данные без изменений. Если вам нужно включить символ фигурной скобки в литеральный текст, его можно экранировать, дублируя: {{ и }}.

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

replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name        ::=  arg_name ("." attribute_name | "[" element_index "]")*
arg_name          ::=  [identifier | integer]
attribute_name    ::=  identifier
element_index     ::=  integer | index_string
index_string      ::=  <any source character except "]"> +
conversion        ::=  "r" | "s"
format_spec       ::=  <described in the next section>

В менее формальном плане, поле замены может начинаться с field_name, которое определяет объект, значение которого должно быть отформатировано и вставлено в выходные данные вместо поля замены. field_name необязательно может быть дополнен полем conversion, которое предваряется восклицательным знаком '!', и format_spec, которое предваряется двоеточием ':'. Эти параметры определяют нестандартное форматирование значения замены.

См. также раздел Мини-язык спецификации формата.

Само field_name начинается с arg_name, которое является либо числом, либо ключевым словом. Если это число, оно относится к позиционному аргументу, а если это ключевое слово, оно относится к именованному аргументу. Если числовые arg_name в строке формата следуют последовательно 0, 1, 2, …, они все могут быть опущены (не только некоторые) и числа 0, 1, 2, … будут вставлены автоматически в этом порядке. Так как arg_name не заключено в кавычки, невозможно указать произвольные ключи словаря (например, строки '10' или ':-]' внутри строки формата. arg_name может быть дополнен любым количеством выражений индексирования или атрибутов. Выражение в форме '.name' выбирает именованный атрибут с помощью getattr(), в то время как выражение в форме '[index]' выполняет поиск по индексу с помощью __getitem__().

Примеры простых строк формата:

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Поле conversion вызывает принудительное преобразование типа перед форматированием. Обычно задача форматирования значения выполняется методом __format__() самого значения. Однако в некоторых случаях желательно принудительно отформатировать тип как строку, переопределяя собственное определение форматирования. Преобразуя значение в строку перед вызовом __format__(), стандартная логика форматирования обходится.

В настоящее время поддерживаются два флага преобразования: '!s' , который вызывает str() для значения, и '!r' , который вызывает repr().

Примеры:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

Поле format_spec содержит описание того, как должно быть представлено значение, включая такие детали, как ширина поля, выравнивание, заполнение, десятичная точность и так далее. Каждый тип значений может определить свой собственный «мини-язык форматирования» или интерпретацию format_spec.

Большинство встроенных типов поддерживают общий мини-язык форматирования, который описан в следующем разделе.

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

См. раздел Примеры форматирования для примеров.

3.1. Спецификация формата языка мини-языка

“Спецификации формата” используются внутри полей замены, содержащихся в строке формата, чтобы определить, как представляются отдельные значения (см. Синтаксис строки формата). Их также можно передать непосредственно встроенной функции format(). Каждый форматируемый тип может определить, как интерпретировать спецификацию формата.

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

Общим соглашением является то, что пустая строка формата ("") даёт тот же результат, что и вызов функции str() для значения. Непустая строка формата обычно изменяет результат.

Общая форма стандартного спецификатора формата:

format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
fill        ::=  <any character>
align       ::=  "<" | ">" | "=" | "^"
sign        ::=  "+" | "-" | " "
width       ::=  integer
precision   ::=  integer
type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Если указано допустимое значение выравнивания, ему может предшествовать символ заполнения, который может быть любым символом, и по умолчанию является пробелом, если не указано иное. Невозможно использовать литеральный фигурную скобку (“{” или “}”) в качестве символа заполнения при использовании метода str.format(). Однако можно вставить фигурную скобку с вложенным полем замены. Это ограничение не влияет на функцию format().

Значение различных параметров выравнивания следующие:

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

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

Параметр '#' допустим только для целых чисел и только для двоичного, восьмеричного или шестнадцатеричного вывода. При наличии он указывает, что вывод будет префиксами '0b', '0o', или '0x', соответственно.

Параметр ',' указывает на использование запятой в качестве разделителя тысяч. Для использования разделителя, зависящего от локали, используйте целочисленный тип представления 'n'.

width — десятичное целое число, определяющее минимальную ширину поля. Если не указано, ширина поля определяется содержимым.

Если не указано явного выравнивания, добавление символа ноль ('0') перед полем width включает в себя знаково-осознанное нулевое заполнение для числовых типов. Это эквивалентно символу fill '0' с типом alignment '='.

precision — десятичное число, указывающее, сколько цифр должно быть отображено после десятичной точки для числа с плавающей точкой, отформатированного с 'f' и 'F', или до и после десятичной точки для числа с плавающей точкой, отформатированного с 'g' или 'G'. Для типов, не являющихся числами, поле указывает максимальный размер поля — другими словами, сколько символов будет использоваться из содержимого поля. precision не разрешено для целых значений.

Наконец, type определяет, как должны быть представлены данные.

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

Доступные целочисленные типы представления:

В дополнение к вышеперечисленным типам представления целые числа могут быть отформатированы с типами представления чисел с плавающей точкой, перечисленными ниже (за исключением 'n' и None). При этом используется float() для преобразования целого числа в число с плавающей точкой перед форматированием.

Доступные типы представления для чисел с плавающей точкой и десятичных значений:

3.2. Примеры формата

Этот раздел содержит примеры синтаксиса str.format() и сравнение со старым форматом %.

В большинстве случаев синтаксис похож на старый формат % с добавлением {} и использованием : вместо %. Например, '%03.2f' может быть переведено в '{:03.2f}'.

Новый синтаксис формата также поддерживает новые и разные параметры, показанные в следующих примерах.

Доступ к аргументам по позиции:

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
'abracadabra'

Доступ к аргументам по имени:

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

Доступ к атрибутам аргументов:

>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point(object):
...     def __init__(self, x, y):
...         self.x, self.y = x, y
...     def __str__(self):
...         return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'

Доступ к элементам аргументов:

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'

Замена %s и %r:

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"

Выравнивание текста и указание ширины:

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

Замена %+f, %-f, и % f и указание знака:

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

Замена %x и %o и преобразование значения в разные системы счисления:

>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

Использование запятой в качестве разделителя тысяч:

>>> '{:,}'.format(1234567890)
'1,234,567,890'

Выражение процента:

>>> points = 19.5
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 88.64%'

Использование форматирования, специфичного для типа:

>>> import datetime
>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'

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

>>> for align, text in zip('<^>', ['left', 'center', 'right']):
...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12):
...     for base in 'dXob':
...         print '{0:{width}{base}}'.format(num, base=base, width=width),
...     print
...
    5     5     5   101
    6     6     6   110
    7     7     7   111
    8     8    10  1000
    9     9    11  1001
   10     A    12  1010
   11     B    13  1011

4. Строки-шаблоны

Шаблоны обеспечивают более простые подстановки строк, как описано в PEP 292. Вместо обычных %-основанных подстановок, Шаблоны поддерживают $-основанные подстановки, используя следующие правила:

• $$ — это escape; он заменяется на один $.
• $identifier задаёт заполнитель подстановки, соответствующий ключу отображения "identifier". По умолчанию "identifier" должен соответствовать Python-идентификатору. Первый символ, не являющийся идентификатором, после символа $ завершает это указание заполнителя.
• ${identifier} эквивалентно $identifier. Это необходимо, когда за заполнителем следуют допустимые символы идентификатора, но они не входят в состав заполнителя, например, "${noun}ification".

Любое другое появление $ в строке приведёт к поднятию исключения ValueError.

Модуль string предоставляет класс Template, который реализует эти правила. Методы класса Template:

class string.Template(template)

Конструктор принимает один аргумент, который является строкой-шаблоном.

substitute(mapping[, **kws])

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

safe_substitute(mapping[, **kws])

Подобно substitute(), за исключением того, что если заполнители отсутствуют в mapping и kws, вместо поднятия исключения KeyError исходный заполнитель появится в результирующей строке без изменений. Также, в отличие от substitute(), любые другие появления $ просто вернут $ вместо поднятия исключения ValueError.

Хотя могут возникнуть и другие исключения, этот метод называется «безопасным», потому что он всегда пытается вернуть используемую строку вместо поднятия исключения. В другом смысле, safe_substitute() может быть чем-то другим, кроме безопасного, поскольку он будет молча игнорировать неправильно сформированные шаблоны, содержащие свободные разделители, несоответствующие фигурные скобки или заполнители, которые не являются допустимыми Python-идентификаторами.

Экземпляры Template также предоставляют одно общедоступное свойство:

template

Это объект, переданный в аргумент template конструктора. Как правило, его не следует изменять, но доступ для чтения только для чтения не навязывается.

Вот пример использования шаблона:

>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='kung pao')
'tim likes kung pao'
>>> d = dict(who='tim')
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
...
ValueError: Invalid placeholder in string: line 1, col 11
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
...
KeyError: 'what'
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'

Расширенное использование: вы можете создать подклассы Template, чтобы настроить синтаксис заполнителя, символ разделителя или весь регулярный шаблон, используемый для разбора строк шаблонов. Для этого вы можете переопределить эти свойства класса:

• delimiter — это литеральная строка, описывающая разделитель заполнителя. Значение по умолчанию — $. Обратите внимание, что это не должно быть регулярное выражение, так как реализация будет вызывать re.escape() для этой строки по мере необходимости.
• idpattern — это регулярное выражение, описывающее шаблон для заполнителей без фигурных скобок (фигурные скобки будут добавлены автоматически при необходимости). Значение по умолчанию — регулярное выражение [_a-z][_a-z0-9]*.

В качестве альтернативы, вы можете предоставить весь шаблон регулярного выражения, переопределив свойство класса pattern. В этом случае значение должно быть объектом регулярного выражения с четырьмя именованными группами захвата. Группы захвата соответствуют правилам, приведенным выше, а также правилу невалидного заполнителя:

• escaped — эта группа соответствует последовательности escape, например, $$, в стандартном шаблоне.
• named — эта группа соответствует имени заполнителя без фигурных скобок; она не должна включать разделитель в группе захвата.
• braced — эта группа соответствует имени заполнителя в фигурных скобках; она не должна включать ни разделитель, ни фигурные скобки в группе захвата.
• invalid — эта группа соответствует любому другому шаблону разделителя (обычно одиночному разделителю), и она должна быть последней в регулярном выражении.

5. Функции для строк

Следующие функции доступны для работы со строками и объектами Unicode. Они недоступны как методы строк.

string.capwords(s[, sep])

Разделяет аргумент на слова с помощью str.split(), преобразует каждое слово в верхний регистр с помощью str.capitalize() и объединяет капитализированные слова с помощью str.join(). Если необязательный второй аргумент sep отсутствует или None, последовательности символов пробела заменяются на один пробел, а начальные и конечные пробелы удаляются, в противном случае sep используется для разделения и объединения слов.

string.maketrans(from, to)

Возвращает таблицу преобразования, подходящую для передачи в translate(), которая будет отображать каждый символ в from в символ на той же позиции в to; from и to должны иметь одинаковую длину.

Примечание

Не используйте строки, полученные из lowercase и uppercase в качестве аргументов; в некоторых локалях они не имеют одинаковой длины. Для преобразования регистра используйте всегда str.lower() и str.upper().

6. Устаревшие функции для строк

Следующий список функций также определён как методы объектов строк и Unicode; см. раздел Методы строк для получения дополнительной информации. Вы должны рассматривать эти функции как устаревшие, хотя они не будут удалены до Python 3. Функции, определённые в этом модуле:

string.atof(s)

Устарело начиная с версии 2.0: Используйте встроенную функцию float().

Преобразует строку в число с плавающей точкой. Строка должна иметь стандартный синтаксис для литерала с плавающей точкой в Python, необязательно предваряемого знаком (+ или -). Обратите внимание, что это поведение идентично встроенной функции float(), если ей передаётся строка.

Примечание

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

string.atoi(s[, base])

Устарело начиная с версии 2.0: Используйте встроенную функцию int().

Преобразуйте строку s в целое число в заданном основании. Строка должна содержать одну или несколько цифр, необязательно предваряемые знаком (+ или -). Основание по умолчанию равно 10. Если оно равно 0, основание выбирается по умолчанию в зависимости от начальных символов строки (после удаления знака): 0x или 0X означает 16, 0 означает 8, в противном случае – 10. Если основание равно 16, ведущие 0x или 0X всегда принимаются, хотя и не являются обязательными. Это поведение идентично встроенной функции int() при передаче строки. (Также обратите внимание: для более гибкой интерпретации числовых литералов используйте встроенную функцию eval().)

string.atol(s[, base])

Устарело начиная с версии 2.0: Используйте встроенную функцию long().

Преобразуйте строку s в целое число типа long в заданном основании. Строка должна содержать одну или несколько цифр, необязательно предваряемые знаком (+ или -). Аргумент основание имеет тот же смысл, что и для atoi(). Завершающие l или L не разрешены, за исключением случая, когда основание равно 0. Обратите внимание, что при вызове без основания или с основанием, равным 10, это поведение идентично встроенной функции long() при передаче строки.

string.capitalize(word)

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

string.expandtabs(s[, tabsize])

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

string.find(s, sub[, start[, end]])

Возвращает наименьший индекс в s, где подстрока sub найдена таким образом, что sub полностью содержится в s[start:end]. Возвращает -1 при неудаче. Значения по умолчанию для start и end и интерпретация отрицательных значений такая же, как и для срезов.

string.rfind(s, sub[, start[, end]])

Как find(), но находит наибольший индекс.

string.index(s, sub[, start[, end]])

Как find(), но вызывает ValueError, когда подстрока не найдена.

string.rindex(s, sub[, start[, end]])

Как rfind(), но вызывает ValueError, когда подстрока не найдена.

string.count(s, sub[, start[, end]])

Возвращает количество (неперекрывающихся) вхождений подстроки sub в строке s[start:end]. Значения по умолчанию для start и end и интерпретация отрицательных значений такие же, как и для срезов.

string.lower(s)

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

string.split(s[, sep[, maxsplit]])

Возвращает список слов строки s. Если необязательный второй аргумент sep отсутствует или None, слова разделяются произвольными строками символов пробела (пробел, табуляция, новая строка, возврат каретки, разделитель страницы). Если второй аргумент sep присутствует и не None, он указывает строку, используемую в качестве разделителя слов. Возвращаемый список будет иметь на один элемент больше, чем количество неперекрывающихся вхождений разделителя в строке. Если задан maxsplit, выполняется не более maxsplit разбиений, и остаток строки возвращается в качестве последнего элемента списка (таким образом, список будет иметь не более maxsplit+1 элементов). Если maxsplit не указан или -1, то нет ограничений на количество разбиений (производится все возможные разбиения).

Поведение split для пустой строки зависит от значения sep. Если sep не указан или указан как None, результат будет пустым списком. Если sep указан как любая строка, результат будет списком, содержащим один элемент, который является пустой строкой.

string.rsplit(s[, sep[, maxsplit]])

Возвращает список слов строки s, сканируя s с конца. Во всех отношениях, полученный список слов такой же, как возвращаемый split(), за исключением случаев, когда явным образом задан необязательный третий аргумент maxsplit и он не равен нулю. Если maxsplit задан, происходит не более maxsplit разбиений – наиболее правых – и остаток строки возвращается в качестве первого элемента списка (таким образом, список будет иметь не более maxsplit+1 элементов).

Новая в версии 2.4.

string.splitfields(s[, sep[, maxsplit]])

Эта функция ведет себя идентично split(). (В прошлом split() использовалась только с одним аргументом, в то время как splitfields() использовалась только с двумя аргументами.)

string.join(words[, sep])

Объединяет список или кортеж слов с промежуточными появлениями sep. Значение по умолчанию для sep — одиночный символ пробела. Всегда верно, что string.join(string.split(s, sep), sep) равно s.

string.joinfields(words[, sep])

Эта функция ведет себя идентично join(). (В прошлом join() использовалась только с одним аргументом, в то время как joinfields() использовалась только с двумя аргументами.) Обратите внимание, что метода joinfields() на объектах строк нет; используйте метод join() вместо него.

string.lstrip(s[, chars])

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

Изменено в версии 2.2.3: Добавлен параметр chars. Параметр chars не может быть передан в более ранних версиях 2.2.

string.rstrip(s[, chars])

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

Изменено в версии 2.2.3: Добавлен параметр chars. Параметр chars не может быть передан в более ранних версиях 2.2.

string.strip(s[, chars])

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

Изменено в версии 2.2.3: Добавлен параметр chars. Параметр chars не может быть передан в более ранних версиях 2.2.

string.swapcase(s)

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

string.translate(s, table[, deletechars])

Удаляет все символы из s, которые находятся в deletechars (если присутствуют), а затем преобразует символы с помощью table, которая должна быть строкой длиной 256 символов, дающей преобразование для каждого символа, индексированного его порядковым значением. Если table None, выполняется только этап удаления символов.

string.upper(s)

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

string.ljust(s, width[, fillchar])

string.rjust(s, width[, fillchar])

string.center(s, width[, fillchar])

Эти функции соответственно выравнивают строку влево, вправо и по центру в поле заданной ширины. Они возвращают строку, ширина которой не менее ширины символов, созданную путём дополнения строки s символом fillchar (по умолчанию пробел) до заданной ширины справа, слева или с обеих сторон. Строка никогда не обрезается.

string.zfill(s, width)

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

string.replace(s, old, new[, maxreplace])

Возвращает копию строки s со всеми вхождениями подстроки old, заменёнными на new. Если необязательный аргумент maxreplace задан, заменятся первые maxreplace вхождений.