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

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


Строковые константы

В этом модуле определены следующие константы:

string.ascii_letters

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

string.ascii_lowercase

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

string.ascii_uppercase

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

string.digits

Строка '0123456789'.

string.hexdigits

Строка '0123456789abcdefABCDEF'.

string.octdigits

Строка '01234567'.

string.punctuation

Строка символов ASCII, которые считаются знаками препинания в C локали: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~.

string.printable

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

string.whitespace

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

Пользовательское форматирование строк

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

class string.Formatter

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

format(format_string, /, *args, **kwargs)

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

Изменено в версии 3.7: Теперь строка аргумента только-позиционного формата.

vformat(format_string, args, kwargs)

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

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

parse(format_string)

Закольцовывают format_string и возвращает итератор кортежей (literal_text, field_name, format_spec, conversion). Это используемый vformat() разбить строку на литерал текстового поля или поля замены.

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

get_field(field_name, args, kwargs)

Если field_name возвращенный parse() (см. выше), преобразовать его в форматируемый объект. Возвращает кортеж (obj, used_key). Версия по умолчанию строки форму, определенную в PEP 3101, например «0 [name]» или «label.titl.» 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, переданные формату. Набор неиспользуемых аргументов можно вычислить на основе этих параметров. Предполагается, что check_unused_args() вызывает исключение в случае неспешного завершения проверки.

format_field(value, format_spec)

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

convert_field(value, conversion)

Преобразует значение (возвращенный по get_field()), заданный тип преобразования (как в кортеже, возвращенный методом parse()). Версия по умолчанию определяет типы преобразования „s“ (str), „r“ (repr) и „a“ (ascii).

Синтаксис format строки

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

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

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

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

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

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

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

Изменено в версии 3.1: Спецификаторы позиционных аргументов могут быть опущены для str.format(), поэтому '{} {}'.format(a, b) эквивалентно '{0} {1}'.format(a, b).

Изменено в версии 3.4: Указатели позиционных аргументов могут быть опущены для Formatter.

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

"First, thou shalt count to {0}"  # Ссылки на первый позиционный аргумент
"Bring me a {}"                   # Неявно ссылается на первый позиционный аргумент
"From {} to {}"                   # То же, что "From {0} to {1}"
"My quest is {name}"              # Ссылка на ключевое аргумент «name»
"Weight in tons {0.weight}"       # атрибут 'weight' первого позиционного аргумента
"Units destroyed: {players[0]}"   # Первый элемент ключевого аргумента «players».

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

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

Некоторые примеры:

"Harold's a clever {0!s}"        # Сначала вызывает str() для аргумента
"Bring out the holy {name!r}"    # Сначала вызывает repr() для аргумента
"More {!a}"                      # Сначала вызывает ascii() для аргумента

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

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

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

Некоторые примеры см. в разделе Примеры формата.

Мини-язык спецификации формата

«Спецификации формата» используемый в полях замены, содержащихся в строка формата, для определения способа представления отдельных значения (см. Синтаксис format строки и Форматированные строковые литералы). Они также могут быть переданы непосредственно встроенной функции format(). Каждый форматируемый тип может определять способ интерпретации спецификации формата.

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

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

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

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

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

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

Опция Значение
'<' Заставляет поле выравниваться по левому краю в пределах доступного пространства (это значение по умолчанию для большинства объектов).
'>' Заставляет поле выравниваться по правому краю в доступном пространстве (это значение по умолчанию для чисел).
'=' Принудительно помещает заполнение после знака (если имеется), но перед цифрами. Используется для печати полей в форме „+000000120“. Параметр выравнивания допустим только для числовых типов. Он становится значением по умолчанию, когда „0“ сразу предшествует ширине поля.
'^' Принудительное центрирование поля в пределах доступного пространства.

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

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

Опция Значение
'+' указывает, что знак должен использоваться как для положительных, так и для отрицательных чисел.
'-' указывает, что знак должен использоваться только для отрицательных чисел (это поведение по умолчанию).
пробел указывает, что ведущий пробел должен использоваться на положительных числах, а знак минус - на отрицательных числах.

Параметр '#' приводит к используемый «альтернативной формы» для преобразования. Альтернативная форма определяется по-разному для различных типов. Этот параметр допустим только для целочисленных, float, комплексных и десятичных типов. Для целых чисел при используемый двоичного, восьмеричного или шестнадцатеричного вывода эта опция добавляет к выходному '0b' префикс, соответствующий '0o', '0x' или значение. Для floats, complex и Decimal альтернативная форма приводит к тому, что результат преобразования всегда содержит десятичный символ, даже если за ним не следуют цифры. Обычно десятичная точка символ появляется в результате этих преобразований, только если за ней следует цифра. Кроме того, для 'g' и 'G' преобразований конечные нули не удаляются из результата.

Опция ',' сигнализирует об использовании запятой для разделителя тысяч. Для разделителя с поддержкой локали используйте тип представления integer 'n'.

Изменено в версии 3.1: Добавлена опция ',' (см. также PEP 378).

Опция '_' сигнализирует об использовании подчеркивания для разделителя тысяч для типов представления с плавающей запятой и для типа представления целого числа 'd'. Для целочисленных типов представления 'b', 'o', 'x' и 'X' подчеркивания вставляются каждые 4 цифры. Для других типов презентаций указание этого параметра является ошибкой.

Изменено в версии 3.6: Добавлена опция '_' (см. также PEP 515).

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

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

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

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

Доступные типы презентаций строка:

Тип Значение
's' Строковый формат. Этот тип является типом по умолчанию для строки и может быть пропущен.
None То же, что и 's'.

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

Тип Значение
'b' Двоичный формат. Выводит число по основанию 2.
'c' Символ. Преобразует целое число в соответствующее символ Юникода перед печатью.
'd' Десятичное целое число. Выводит число по основанию 10.
'o' Октальный формат. Выводит число по основанию 8.
'x' Шестнадцатеричный формат. Выводит число по основанию 16, используя строчные буквы для цифр больше 9.
'X' Шестнадцатеричный формат. Выводит число по основанию 16, используя прописные буквы для цифр выше 9.
'n' Число. Это то же самое, что и 'd', за исключением того, что для вставки соответствующих символов-разделителей номеров используется текущий параметр локали.
None То же, что и 'd'.

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

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

Тип Значение
'e' Экспоненциальная нотация. Печатает число в научной нотации, используя букву „e“ для обозначения экспоненты. Точность по умолчанию - 6.
'E' Экспоненциальная нотация. То же самое, что и 'e', за исключением того, что он использует верхний регистр „E“ в качестве разделителя символов.
'f' Представление с фиксированной точкой. Отображает число в виде числа с фиксированной точкой. По умолчанию используется точность 6.
'F' Представление с фиксированной точкой. То же, что и 'f', но преобразует nan в NAN и inf в INF.
'g'

GОбщий формат. Для заданной точности p >= 1 это округляет число до p значащих цифр и затем форматирует результат либо в формате с фиксированной точкой, либо в научном представлении, в зависимости от его величины.

Точные правила таковы: предположим, что результат отформатирован с типом представления 'e' и p-1 точности, будет иметь exp экспоненты. Затем, если m <= exp < p, где m равно -4 для floats и -6 для Decimals, число форматируется с типом представления 'f' и точностью p-1-exp. В противном случае номер форматируется с помощью 'e' типа представления и p-1 точности. В обоих случаях из значащего удаляются незначительные конечные нули, а десятичная точка также удаляется, если после нее нет оставшихся цифр, если не используется опция '#'.

Положительные и отрицательные бесконечности, положительный и отрицательный ноль и nan, форматируются как inf, -inf, 0, -0 и nan соответственно, независимо от точности.

Точность 0 рассматривается как эквивалентная точности 1. По умолчанию используется точность 6.

'G' Общий формат. То же, что и 'g', за исключением переключения на 'E', если число становится слишком большим. Представления бесконечности и NaN также в верхнем регистре.
'n' Номер. Это то же самое, что и 'g', за исключением того, что он использует текущую настройку локали для вставки соответствующих символов разделителя чисел.
'%' Процент. Умножает число на 100 и отображает в фиксированном ('f') формате, за которым следует знак процента.
None Аналогично 'g', за исключением того, что обозначение с фиксированной точкой, когда оно используется, имеет по крайней мере одну цифру после десятичной точки. Точность по умолчанию настолько высока, насколько это необходимо для представления конкретного значения. Общий эффект заключается в том, чтобы соответствовать выходу str(), измененному другими модификаторами формата.

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

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

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

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

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

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ только
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')      # распаковка последовательности аргументов
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')   # индексы аргументов могут повторяться
'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:
...     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')  # использовать "*" в качестве символа заполнителя
'***********centered***********'

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

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # показывать это всегда
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # показать пробел для положительных чисел
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # показать только минус - то же, что и '{: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
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'

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

>>> 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), end=' ')
...     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

Строковые шаблоны

Строки шаблона обеспечивают более простые замены строки, как описано в PEP 292. Основным примером использования строки шаблонов является интернационализация (i18n), поскольку в этом контексте более простой синтаксис и функциональные возможности упрощают перевод по сравнению с другими встроенными средствами форматирования строки в Python. В качестве примера библиотеки, построенной на шаблонных строки для i18n, см. пакет flufl.i18n.

Строки шаблона поддерживают $ замены, используя следующие правила:

  • $$ - это экранирование; он заменяется на одиночный $.
  • $identifier именует местозаполнитель подстановки, соответствующий ключу сопоставления "identifier". По умолчанию "identifier" ограничивается любой алфавитно-цифровой строкой ASCII без учета регистра (включая подчеркивания), начинающимся с символа подчеркивания или буквы ASCII. Первый неидентификационный символ после $ символ завершает эту спецификацию местозаполнителя.
  • ${identifier} эквивалентно $identifier. Он требуется, когда допустимые символы идентификатора следуют за местозаполнителем, но не являются частью местозаполнителя, например "${noun}ification".

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

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

class string.Template(template)

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

substitute(mapping={}, /, **kwds)

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

safe_substitute(mapping={}, /, **kwds)

Как и substitute(), за исключением того, что если местозаполнители отсутствуют в mapping и kwds, вместо создания 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 - это литерал строка, описывающий местозаполнитель, вводящий разделитель. По умолчанию используется значение $. Обратите внимание, что это not должно быть регулярным выражением, поскольку реализация потребует re.escape() по этому строка по мере необходимости. Обратите внимание далее, что вы не можете изменить разделитель после создания класса (т.е. другой разделитель должен быть установлен в пространстве имен класса подкласс).

  • idpattern – это регулярное выражение, описывающее шаблон для местозаполнителей без скобок. значение по умолчанию является (?a:[_a-z][_a-z0-9]*) регулярного выражения. Если это задано и braceidpattern None этот шаблон также применяется к местозаполнителям с раскосами.

    Примечание

    Поскольку flags по умолчанию равно re.IGNORECASE, [a-z] шаблона могут совпадать с некоторыми символами, отличными от ASCII. Вот почему мы используем здесь флаг локальная a.

    Изменено в версии 3.7: braceidpattern можно используемый для определения отдельных шаблонов используемый внутри и снаружи фигурных скобок.

  • braceidpattern - это как idpattern, но описывает шаблон для разделенных местозаполнителей. Значение по умолчанию - None, что означает возврат к idpattern (т.е. один и тот же шаблон используемый как внутри, так и снаружи фигурных скобок). Если этот параметр задан, можно определить различные шаблоны для местозаполнителей с раскосами и без раскосов.

    Добавлено в версии 3.7.

  • flags - флаги регулярных выражений, которые будут применяться при компиляции используемый регулярных выражений для распознавания замен. По умолчанию используется значение re.IGNORECASE. Обратите внимание, что re.VERBOSE всегда будут добавляться к флагам, поэтому пользовательский idpatterns должен следовать соглашениям для подробных регулярных выражений.

    Добавлено в версии 3.2.

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

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

Функции хелперы

string.capwords(s, sep=None)

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