Il modulo string risale alle prime versioni di Python. Molte delle funzioni precedentemente implementate in questo modulo sono state spostate verso metodi degli oggetti str. Il modulo string conserva parecchie classi e costanti utili per lavorare con oggetti str. Questo articolo si concentra su di essi.

Funzioni

La funzione capwords() trasforma in maiuscolo il carattere iniziale di ogni parola in una stringa.

# string_capwords.py

import string

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

print(s)
print(string.capwords(s))

Il risultato è uguale a quello che si otterrebbe dalla chiamata di split(), dalla successiva trasformazione in maiuscolo della prima lettera di ogni elemento della lista risultante, e infine dalla ricostruzione della stringa originale con l'istruzione join().

$ python3 string_capwords.py

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

Modelli

I modelli di stringa sono stati introdotti come parte del PEP 292 e sono concepiti come alternativa della sintassi built-in di interpolazione. Con l'interpolazione di string.Template, le variabili sono definite prefissandone il nome con un $, (es. $var). In alternativa, se necessario separarle dal testo circostante possono anche essere racchiuse tra parentesi graffe (es. ${var}).

Questo esempio confronta un semplice modello con una interpolazione di stringa simile utilizzando l'operatore % e il nuovo formato di sintassi di stringa usando str.format().

# string_template.py

import string


values = {'var': 'foo'}

t = string.Template("""
Variabile         : $var
Escape            : $$
Variabile in testo: ${var}iable
""")

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

s = """
Variabile         : %(var)s
Escape            : %%
Variabile in testo: %(var)siable
"""

print('INTERPOLAZIONE:', s % values)

s = """
Variabile         : {var}
Escape            :  {{}}
Variabile in testo: {var}iable
"""

print('FORMAT:', s.format(**values))

Nei primi due casi, il carattere di ingaggio ($ o %) viene non viene considerato ripetendolo due volte. Per la sintassi di str.format(), entrambe le parentesi graffe vanno ripetute se non devono essere considerate come caratteri scatenanti.

$ python3 string_template.py

MODELLO: 
Variabile         : foo
Escape            : $
Variabile in testo: fooiable

INTERPOLAZIONE: 
Variabile         : foo
Escape            : %
Variabile in testo: fooiable

FORMAT: 
Variabile         : foo
Escape            :  {}
Variabile in testo: fooiable

Una differenza chiave tra modelli e interpolazione o formattazione di stringa è che il tipo degli argomenti non viene preso in considerazione. I valori sono convertiti in stringhe, e le stringhe sono inserite nel risultato. Non sono disponibili opzioni di formattazione. Ad esempio, non vi è modo di controllare il numero di cifre usate per rappresentare un valore a virgola mobile.

Un beneficio, tuttavia, è che l'uso del metodo safe_substitute(), rende possibile evitare eccezioni se non tutti i valori necessari al modello sono stati passati come argomenti.

# string_template_missing.py

import string


values = {'var': 'foo'}

t = string.Template("$var è qui ma $missing non è stato fornito")

try:
    print('substitute()     :', t.substitute(values))
except KeyError as err:
    print('ERRORE:', str(err))

print('safe_substitute():', t.safe_substitute(values))

Viso che qui non esiste un valore per missing nel dizionario values, viene sollevata una eccezione KeyError da substitute(). Invece di sollevare l'eccezione, safe_substitute() la cattura e lascia il nome della variabile come parte del testo restituito.

$ python3 string_template_missing.py

ERRORE: 'missing'
safe_substitute(): foo è qui ma  non è stato fornito

Modelli Avanzati

La sintassi predefinita per string.Template, può essere modificata aggiustando gli schemi di espressione regolare che usa per trovare i nomi delle variabili nel corpo del modello. Un modo semplice per fare questo è modificare gli attributi di classe delimiter e idpattern.

# string_template_advanced.py

import string


class MyTemplate(string.Template):
    delimiter = '%'
    idpattern = '[a-z]+_[a-z]+'


template_text = '''
  Delimitatore: %%
  Sostituito  : %with_underscore
  Ignorato    : %notunderscored
'''

d = {
    'with_underscore': 'sostituito',
    'notunderscored': 'non sostituito',
}

t = MyTemplate(template_text)
print('Modificato il modello ID:')
print(t.safe_substitute(d))

In questo esempio sono modificate le regole di sostituzione in modo che il delimitatore sia % invece che $ e i nomi delle variabili devono contenere un _ da qualche parte all'interno. Lo schema %notunderscored non viene sostituito da niente, visto che non include un carattere di sottolineatura _.

$ python3 string_template_advanced.py

Modificato il modello ID:

  Delimitatore: %
  Sostituito  : sostituito
  Ignorato    : %notunderscored

Per modifiche ancora più complesse, è possibile sovrascrivere l'attributo pattern e definire una espressione regolare completamente nuova. Lo schema fornito deve contenere quattro gruppi nominativi per catturare il delimitatore, la variabile nominativa, la versione tra parentesi graffe del nome della variabile e gli schemi di delimitatore non valido.

# string_template_defaultpattern.py

import string


t = string.Template('$var')
print(t.pattern.pattern)

Il valore di t.pattern è una espressione regolare compilata, ma la stringa originale è disponibile attraverso l'attributo pattern.

$ python3 string_template_defaultpattern.py


    \$(?:
      (?P<escaped>\$) |   # Escape sequence of two delimiters
      (?P<named>(?a:[_a-z][_a-z0-9]*))      |   # delimiter and a Python identifier
      {(?P<braced>(?a:[_a-z][_a-z0-9]*))}  |   # delimiter and a braced identifier
      (?P<invalid>)              # Other ill-formed delimiter exprs
    )
    

Questo esempio definisce un nuovo schema per creare un nuovo tipo di modello, usando come sintassi della variabile {{var}}}.

# string_template_newsyntax.py

import re
import string


class MyTemplate(string.Template):
    delimiter = '{{'
    pattern = r'''
    \{\{(?:
    (?P<escaped>\{\{)|
    (?P<named>[_a-z][_a-z0-9]*)\}\}|
    (?P<braced>[_a-z][_a-z0-9]*)\}\}|
    (?P<invalid>)
    )
    '''


t = MyTemplate('''
{{{{
{{var}}
''')

print('CORRISPONDENZE:', t.pattern.findall(t.template))
print('SOSSTITUTI    :', t.safe_substitute(var='rimpiazzo'))

Sia lo schema named che quello di braced devono essere forniti separatamente, anche se sono identici. L'esecuzione del programma di esempio genera il seguente risultato:

$ python3 string_template_newsyntax.py

CORRISPONDENZE: [('{{', '', '', ''), ('', 'var', '', '')]
SOSSTITUTI    : 
{{
rimpiazzo

Formatter

La classe Formatter implementa le stesse specifiche di linguaggio del metodo str.format(). Tra le sue caratteristiche la coercizione del tipo, l'allineamento, i riferimenti ad attributo e campi, argomenti di modello nominativi e posizionali e opzioni di formattazione specifiche per tipo. La maggior parte delle volte il metodo format() costituisce una interfaccia più conveniente per queste caratteristiche, ma Formatter è fornito come modo per costruire sottoclassi, per casi dove le variazioni sono necessarie.

Costanti

Il modulo string include costanti in relazione a insiemi ASCII e numerici.

# string_constants.py

import inspect
import string


def is_str(value):
    return isinstance(value, str)


for name, value in inspect.getmembers(string, is_str):
    if name.startswith('_'):
        continue
    print('%s=%r\n' % (name, value))

Queste costanti sono utili quando si lavora con dati ASCII; tuttavia visto che è sempre più frequente avere a che fare con testo non ASCII in una qualche forma di Unicode, la loro applicazione è limitata.

$ python3 string_constants.py

ascii_letters='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

ascii_lowercase='abcdefghijklmnopqrstuvwxyz'

ascii_uppercase='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

digits='0123456789'

hexdigits='0123456789abcdefABCDEF'

octdigits='01234567'

printable='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

punctuation='!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

whitespace=' \t\n\r\x0b\x0c'