Come utilizzare i formattatori di stringhe in Python 3

###Introduzione

Il metodo str.format() della classe stringa di Python consente di eseguire sostituzioni di variabili e formattazione dei valori. Questo ti permette di concatenare elementi all’interno di una stringa tramite formattazione posizionale.

Questo tutorial ti guiderà attraverso alcuni degli utilizzi comuni dei formattatori in Python, che possono aiutarti a rendere il tuo codice e programma più leggibili e user friendly.

Prerequisiti

Dovresti avere Python 3 installato e un ambiente di programmazione configurato sul tuo computer o server. Se non hai un ambiente di programmazione configurato, puoi fare riferimento alle guide di installazione e configurazione per un ambiente di programmazione locale o per un ambiente di programmazione sul tuo server appropriato per il tuo sistema operativo (Ubuntu, CentOS, Debian, ecc.)

##Utilizzo dei Formattatori

I formattatori funzionano inserendo uno o più campi di sostituzione o segnaposto – definiti da una coppia di parentesi graffe {} – in una stringa e chiamando il metodo str.format(). Passerai al metodo il valore che desideri concatenare alla stringa. Questo valore verrà passato nello stesso punto in cui è posizionato il tuo segnaposto quando esegui il programma.

Stampiamo una stringa che utilizza un formattatore:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

Nell’esempio sopra, abbiamo costruito una stringa con una coppia di parentesi graffe come segnaposto:

"Sammy has {} balloons."

Poi abbiamo aggiunto il metodo str.format() e abbiamo passato il valore dell’intero 5 a quel metodo. Questo inserisce il valore di 5 nella stringa dove c’erano le parentesi graffe:

Sammy has 5 balloons.

Possiamo anche assegnare una variabile uguale al valore di una stringa che ha segnaposto del formattatore:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

In questo secondo esempio, abbiamo concatenato la stringa "open source" con la stringa più grande, sostituendo le parentesi graffe nella stringa originale.

I formattatori in Python ti permettono di utilizzare le parentesi graffe come segnaposto per i valori che passerai con il metodo str.format().

## Utilizzare i Formattatori con Più Segnaposti

È possibile utilizzare più coppie di parentesi graffe quando si utilizzano i formattatori. Se vogliamo aggiungere un’altra sostituzione di variabile alla frase sopra, possiamo farlo aggiungendo una seconda coppia di parentesi graffe e passando un secondo valore al metodo:

new_open_string = "Sammy loves {} {}."                      #2 {} segnaposto
print(new_open_string.format("open-source", "software"))    #Passa 2 stringhe al metodo, separate da una virgola

Output
Sammy loves open-source software.

Per aggiungere un’altra sostituzione, abbiamo aggiunto una seconda coppia di parentesi graffe nella stringa originale. Quindi, abbiamo passato due stringhe al metodo str.format(), separandole da una virgola.

Seguendo la stessa sintassi, possiamo aggiungere sostituzioni aggiuntive:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} segnaposto
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Passa 4 stringhe al metodo

Output
Sammy loves open-source software, and has 5 balloons.

In sammy_string abbiamo aggiunto 4 coppie di parentesi graffe come segnaposto per la sostituzione di variabili. Quindi, abbiamo passato 4 valori al metodo str.format(), mescolando stringhe e tipi di dati interi. Ogni di questi valori è separato da una virgola.

##Riordinare i formattatori con argomenti posizionali e per parole chiave

Quando lasciamo le parentesi graffe vuote senza parametri, Python sostituirà i valori passati attraverso il metodo str.format() in ordine. Come abbiamo visto finora, una costruzione del formattatore con due parentesi graffe vuote con due valori passati apparirà così:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

La prima coppia di parentesi graffe viene sostituita con il valore di stringa "squalo", e la seconda coppia viene sostituita con il valore di stringa "pesce pilota".

I valori che esistono all’interno del metodo appaiono così:

("shark", "pilot fish")

Sono essenzialmente il tipo di dato tupla e ogni singolo valore contenuto nella tupla può essere chiamato dal suo numero di indice, che inizia con il numero di indice 0.

Possiamo passare questi numeri di indice tra parentesi graffe che fungono da segnaposto nella stringa originale:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

Nell’esempio sopra, l’output sarà ciò che otteniamo senza passare i numeri di indice tra le parentesi graffe poiché stiamo chiamando i valori nella tupla in ordine:

Output
Sammy the shark has a pet pilot fish!

Ma, se invertiamo i numeri di indice con i parametri dei segnaposto possiamo invertire i valori che vengono passati alla stringa:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Se chiami un numero di indice 2 in una tupla che ha valori alle posizioni degli indici 0 e 1, stai chiamando un valore che è fuori dall’intervallo. Quando chiami un numero di indice che è fuori dall’intervallo, riceverai un messaggio di errore:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

Il messaggio di errore che vediamo si riferisce alla tupla che ha valori solo ai numeri di indice 0 e 1, pertanto il numero di indice 2 è fuori dall’intervallo.

Aggiungiamo alcuni segnaposto in più e alcuni valori in più da passare ad essi, così possiamo capire meglio come riordinare i formattatori. Prima, ecco una nuova stringa con quattro segnaposto:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Senza parametri, i valori che vengono passati al metodo str.format() vengono concatenati nella stringa in ordine.

I valori stringa contenuti nella tupla corrispondono ai seguenti numeri di indice:

Usiamo i numeri di indice dei valori per cambiare l’ordine in cui appaiono nella stringa:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Dato che abbiamo iniziato con l’indice numero 3, abbiamo chiamato per primo l’ultimo valore di "squalo". Gli altri numeri di indice inclusi come parametri cambiano l’ordine in cui le parole appaiono nella stringa originale.

Oltre agli argomenti posizionali, possiamo anche introdurre argomenti con parole chiave che vengono chiamati per il loro nome chiave:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

Questo esempio mostra l’uso di un argomento con parola chiave utilizzato insieme agli argomenti posizionali. Possiamo inserire l’argomento con parola chiave pr insieme agli argomenti posizionali e possiamo spostare questi argomenti per cambiare la stringa risultante:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

Argomenti posizionali e con parole chiave utilizzati con formattatori di stringhe ci danno maggior controllo sulla manipolazione delle nostre stringhe originali attraverso il riordinamento.

##Specificare il Tipo

Possiamo includere più parametri tra le parentesi graffe della nostra sintassi. Useremo la sintassi del codice di formato {nome_campo:conversione}, dove nome_campo specifica l’indice dell’argomento del metodo str.format() che abbiamo visto nella sezione di riordinamento, e conversione si riferisce al codice di conversione del tipo di dati che stai utilizzando con il formattatore.

Il tipo di conversione si riferisce al codice di tipo singolo carattere che Python utilizza. I codici che useremo qui sono s per stringa, d per visualizzare interi decimali (base 10), e f che useremo per visualizzare float con decimali. Puoi leggere di più sulla Mini-Linguaggio di Specifica del Formato attraverso la documentazione ufficiale di Python 3.

Guardiamo un esempio in cui abbiamo un intero passato attraverso il metodo, ma vogliamo visualizzarlo come float aggiungendo l’argomento di tipo di conversione f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

Abbiamo utilizzato la sintassi di {nome_campo:conversione} per il primo campo di sostituzione tra parentesi graffe per produrre un float in output. Le seconde parentesi graffe utilizzano solo il primo parametro {nome_campo}.

Nell’esempio sopra, ci sono molti numeri che vengono visualizzati dopo il punto decimale, ma puoi limitarli. Quando specifici f per i valori float, puoi specificare ulteriormente la precisione di quel valore includendo un punto . seguito dal numero di cifre decimali che desideri includere.

Se Sammy ha mangiato il 75,765367% della pizza, ma non abbiamo bisogno di un alto livello di precisione, possiamo limitare i decimali a 3 aggiungendo .3 prima del tipo di conversione f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

Se vogliamo solo una cifra decimale, possiamo riscrivere la stringa e il metodo in questo modo:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Nota che modificare la precisione farà arrotondare il numero.

Anche se mostriamo un numero senza decimali come float, se cerchiamo di cambiarlo in un intero usando il tipo di conversione d, riceveremo un errore:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

Se desideri non visualizzare decimali, puoi scrivere il tuo formattatore così:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

Questo non convertirà il tuo float in un intero, ma limiterà il numero di cifre mostrate dopo il punto decimale.

##Sostituzioni variabili di riempimento

Poiché i segnaposto sono campi di sostituzione, puoi riempire o creare spazio attorno a un elemento aumentando le dimensioni del campo attraverso parametri aggiuntivi. Questo può essere utile quando abbiamo bisogno di organizzare visivamente molti dati.

Possiamo aggiungere un numero per indicare le dimensioni del campo (in termini di caratteri) dopo i due punti : nelle parentesi graffe della nostra sintassi:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

Nell’esempio sopra, abbiamo dato al numero 5 una dimensione del campo di 4 caratteri e alla stringa balloons una dimensione del campo di 16 caratteri (perché è una stringa lunga).

Come vediamo, per impostazione predefinita le stringhe sono allineate a sinistra all’interno del campo e i numeri sono allineati a destra. Puoi modificare questo inserendo un codice di allineamento dopo i due punti. < allineerà il testo a sinistra in un campo, ^ lo centrerà nel campo e > lo allineerà a destra.

Allineiamo a sinistra il numero e centrare la stringa:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

Ora vediamo che 5 è allineato a sinistra, fornendo spazio nel campo prima di rosso, e palloncini è centrato nel suo campo con spazio a sinistra e a destra.

Per impostazione predefinita, quando rendiamo un campo più grande con i formattatori, Python riempirà il campo con caratteri di spazio bianco. Possiamo modificare ciò per essere un carattere diverso specificando il carattere che vogliamo che sia direttamente dopo i due punti:

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

Stiamo accettando la stringa passata a str.format() nella posizione dell’indice 0 poiché non abbiamo specificato diversamente, inclusi i due punti, e specificando che useremo * invece dello spazio per riempire il campo. Stiamo centrando la stringa con ^, specificando che il campo è di 20 caratteri di dimensione, e indicando anche che stiamo lavorando con un tipo di conversione di stringa includendo s.

Possiamo combinare questi parametri con altri parametri che abbiamo usato in precedenza:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

Nei parametri tra parentesi graffe, abbiamo specificato il numero di campo di indice del float e incluso i due punti, indicato la dimensione del numero di campo e incluso il punto, scritto il numero di posizioni dopo il punto decimale, e poi specificato il tipo di conversione di f.

##Utilizzo delle Variabili

Fino ad ora, abbiamo passato interi, float e stringhe al metodo str.format(), ma possiamo anche passare variabili attraverso il metodo. Questo funziona come qualsiasi altra variabile.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

Possiamo utilizzare variabili sia per la stringa originale che per ciò che viene passato al metodo:

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

Le variabili possono essere facilmente sostituite per ogni parte della costruzione della sintassi del nostro formattatore. Questo rende più semplice lavorare quando stiamo ricevendo input generato dall’utente e assegnando quei valori alle variabili.

##Utilizzare i Formattatori per Organizzare i Dati

I formattatori possono essere apprezzati al meglio quando vengono utilizzati per organizzare molti dati in modo visuale. Se mostriamo database agli utenti, utilizzare i formattatori per aumentare le dimensioni dei campi e modificare l’allineamento può rendere l’output più leggibile.

Guardiamo un tipico ciclo for in Python che stamperà i, i*i e i*i*i nell’intervallo da 3 a 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Anche se l’output è organizzato in un certo modo, i numeri traboccano nelle colonne degli altri, rendendo la parte inferiore dell’output meno leggibile. Se stai lavorando con un set di dati più grande con molti numeri piccoli e grandi, questo può essere un problema.

Utilizziamo i formattatori per dare più spazio a questi numeri:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

Qui, nelle nostre parentesi graffe, non abbiamo aggiunto il nome del campo per il numero di indice e abbiamo iniziato con i due punti, seguito dal numero per le dimensioni del campo e un tipo di conversione d poiché stiamo lavorando con interi. In questo esempio, abbiamo considerato le dimensioni di ciascun output previsto, dando 2 spazi extra per ciascuno, a seconda delle dimensioni del numero massimo possibile, quindi il nostro output appare così:

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

Possiamo specificare un numero di dimensioni del campo coerente per avere colonne uniformi, assicurandoci di accomodare i numeri più grandi:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

Possiamo anche manipolare l’allineamento delle colonne aggiungendo <, ^ e > per l’allineamento del testo, cambiare d in f per aggiungere le cifre decimali, cambiare gli indici dei nomi dei campi e altro ancora per assicurarci che stiamo visualizzando i dati come desideriamo.

##Conclusione

Utilizzare i formattatori per la sostituzione di variabili può essere un modo efficace per concatenare stringhe e organizzare valori e dati. I formattatori rappresentano un modo basilare ma non descrittivo per passare sostituzioni di variabili in una stringa, e sono utili per assicurare che l’output sia leggibile e user friendly.