https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Return to Python Modules, PyMOTW, Python

Python string — Python Text Constants and Python Templates

“Contains Python constants and Python classes for working with Python text.

The Python string module dates from the earliest versions of Python. Many of the Python functions previously implemented in this Python module have been moved to Python methods of str objects. The string module retains several useful Python constants and Python classes for working with Python str objects. This discussion will concentrate on them.

The Python function capwords() Python capitalizes | capitalizes all of the words in a Python string.

string_capwords.py

Python import string | import string

s = 'The quick brown fox jumped over the lazy dog.'

Python print | print(s) print(string.capwords(s)) The results are the same as those obtained by calling [[Python split(), Python capitalizing | capitalizing the words in the resulting Python list, and then calling Python join() to combine the results.

$ python3 string_capwords.py

The quick brown fox jumped over the lazy dog. The Quick Brown Fox Jumped Over The Lazy Dog.

Python templates:

String templates were added as part of PEP 292 and are intended as an alternative to the built-in interpolation syntax. With string.Template interpolation, variables are identified by prefixing the name with $ (e.g., $var). Alternatively, if necessary to set them off from surrounding text, they can also be wrapped with curly braces (e.g., ${var}).

This example compares a simple template with similar string interpolation using the % operator and the new format string syntax using str.format().

string_template.py import string

values = {'var': 'foo'}

t = string.Template(”“” Variable : $var Escape : $$ Variable in text: ${var}iable “”“)

print('TEMPLATE:', t.substitute(values))

s = ”“” Variable : %(var)s Escape : Variable in text: %(var)siable """ print('INTERPOLATION:', s % values) s = """ Variable : {var} Escape : {{}} Variable in text: {var}iable """ print('FORMAT:', s.format(**values)) In the first two cases, the trigger character ($ or %) is escaped by repeating it twice. For the format syntax, both { and } need to be escaped by repeating them. $ python3 string_template.py TEMPLATE: Variable : foo Escape : $ Variable in text: fooiable INTERPOLATION: Variable : foo Escape : % Variable in text: fooiable FORMAT: Variable : foo Escape : {} Variable in text: fooiable One key difference between templates and string interpolation or formatting is that the type of the arguments is not taken into account. The values are converted to strings, and the strings are inserted into the result. No formatting options are available. For example, there is no way to control the number of digits used to represent a floating-point value. A benefit, though, is that use of the safe_substitute() method makes it possible to avoid exceptions if not all of the values needed by the template are provided as arguments. string_template_missing.py import string values = {'var': 'foo'} t = string.Template("$var is here but $missing is not provided") try: print('substitute() :', t.substitute(values)) except KeyError as err: print('ERROR:', str(err)) print('safe_substitute():', t.safe_substitute(values)) Since there is no value for missing in the values dictionary, a KeyError is raised by substitute(). Instead of raising the error, safe_substitute() catches it and leaves the variable expression alone in the text. $ python3 string_template_missing.py ERROR: 'missing' safe_substitute(): foo is here but $missing is not provided Advanced Templates The default syntax for string.Template can be changed by adjusting the regular expression patterns it uses to find the variable names in the template body. A simple way to do that is to change the delimiter and idpattern class attributes. string_template_advanced.py import string class MyTemplate(string.Template): delimiter = '%' idpattern = '[a-z]+_[a-z]+' template_text = ''' Delimiter :

 Replaced  : %with_underscore
 Ignored   : %notunderscored

   'with_underscore': 'replaced',
   'notunderscored': 'not replaced',

 Delimiter : %
 Replaced  : replaced
 Ignored   : %notunderscored

 (?P\$) ]] | [[                # two delimiters
 (?P[_a-z][_a-z0-9]*)    ]] | [[ # identifier
 {(?P[_a-z][_a-z0-9]*)} ]] | [[ # braced identifier
 (?P)                    # ill-formed delimiter exprs

   delimiter = '{{'
   pattern = r'''
   \{\{(?:
   (?P\{\{)]] | [[
   (?P[_a-z][_a-z0-9]*)\}\}]] | [[
   (?P[_a-z][_a-z0-9]*)\}\}]] | [[
   (?P)
   )
   '''

t = MyTemplate(

)

   return isinstance(value, str)

   if name.startswith('_'):
       continue
   print('%s=%r\n' % (name, value))