Interpolazione di stringhe in Python: Guida per principianti

Supponiamo che tu voglia stampare il nome e la professione di una persona. Potresti scrivere un semplice programma come segue.

# Definire le variabili
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output delle informazioni
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

Questo approccio manca di concisione e leggibilità. Fortunatamente, l’interpolazione di stringhe offre una soluzione migliore. Consente di inserire direttamente variabili, espressioni o output di funzioni in una stringa, rendendo la manipolazione delle stringhe dinamica ed eliminando la necessità di concatenazioni manuali.

Utilizzando un approccio di interpolazione di stringhe, potremmo riscrivere il codice come segue.

# Definire le variabili
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output delle informazioni
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

La versione con interpolazione di stringhe consente di incorporare espressioni direttamente all’interno della stringa senza l’uso di concatenazioni disordinate. Come puoi vedere, è un approccio molto più pulito.

Interpolazione di Stringhe di Base in Python

Esistono diverse tecniche di interpolazione di stringhe disponibili in Python. Il metodo più comunemente consigliato è quello delle stringhe formattate, noto anche come f-string, che è disponibile da Python 3.6.

Un altro metodo, comunemente visto nel codice più vecchio di Python 3.6, è il metodo .format(). Anche se questo metodo è più verboso rispetto alle f-string, ha occasionalmente dei vantaggi (dettagli di seguito).

Infine, potresti incontrare % formattazione di tipo -style in codice legacy.

Utilizzando le f-string (Python 3.6+)

f-string (stringhe formattate letterali) sono un modo potente e conciso per formattare le stringhe in Python. Sono state introdotte in Python 3.6 e forniscono un modo leggibile ed efficiente per inserire variabili, espressioni e chiamate di funzioni direttamente nelle stringhe.

Un semplice esempio della sintassi di base di una f-string è il seguente.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)

   My name is Mark.

In questo codice, la variabile output_string è assegnata a una f-string. Il f prefisso prima delle virgolette di apertura indica che la stringa supporta espressioni incorporate. La variabile name viene valutata e il suo valore viene inserito nella stringa, risultando nell’output: "Mi chiamo Mark."

Non solo i valori delle variabili, ma anche calcoli o espressioni possono essere inseriti nelle f-string. Considera questo esempio.

import math


a = 3.0
b = 4.0


# Utilizza l'interpolazione di stringhe per la formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.

L’espressione math.sqrt(a ** 2 + b ** 2) viene valutata direttamente all’interno della stringa, eliminando la necessità di calcolare il valore separatamente prima di inserirlo nella stringa.

Utilizzando il metodo .format()

Come le f-string, il .format() metodo consente di inserire variabili ed espressioni in una stringa. La sintassi di base del .format() metodo è la seguente.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)

   My name is Mark.

Le parentesi graffe {} fungono da segnaposto, segnalando che il valore di una variabile verrà inserito nella stringa in quella posizione. Il valore specifico della variabile inserito nel segnaposto è determinato dall’argomento fornito al .format() metodo.

Argomenti posizionali

Cosa succede se hai bisogno di più segnaposti per più variabili? Considera il seguente codice.

name = 'Mark'
age = 7


# I segnaposti vengono riempiti in ordine degli argomenti
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

In questo esempio, sono necessarie due variabili, name e age. Di conseguenza, la stringa include due segnaposti, e le variabili vengono inserite nello stesso ordine in cui compaiono nel .format() metodo. Questi argomenti sono noti come *posizionali* argomenti perché la loro posizione nella stringa è determinata dalla loro posizione nell’elenco degli argomenti del metodo.

Segnaposti indicizzati e nominati

Come variante dell’idea del segnaposto, considera questo esempio.

name = 'Mark'
age = 7


# Stampare l'età due volte
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Qui, abbiamo riutilizzato il valore della variabile age due volte. Includere la stessa variabile più volte in questo modo è ingombrante e riduce la leggibilità. C’è un modo per riutilizzare una variabile in una stringa formattata con il .format() metodo senza ripeterla? Sì, c’è, usando i cosiddetti *segnaposto indicizzati*.

name = 'Mark'
age = 7


# Usa segnaposto indicizzati
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

In questo esempio, abbiamo definito esplicitamente l’ordine delle variabili all’interno delle parentesi graffe, seguendo l’indicizzazione zero-based di Python. Inoltre, abbiamo riutilizzato la variabile all’indice 1 invece di ripeterla.

Come alternativa all’indicizzazione posizionale, puoi anche utilizzare argomenti nominati, dove ogni argomento viene dato un nome.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))

   My name is Mark and I am 7 years old.

L’argomento nominato è valutato all’interno delle parentesi graffe che specificano il suo nome. Di conseguenza, il {name} segnaposto viene sostituito con il valore "Mark", e il {age} segnaposto viene sostituito con 30.

Utilizzando l’operatore %.

Il metodo finale per l’interpolazione di stringhe è l’operatore %. Funziona in modo simile al comando printf() in C. Il suo utilizzo è deprecato e fortemente sconsigliato a favore delle f-string o del metodo .format(). Viene menzionato qui perché potresti trovarlo in codebase legacy.

Il formato base per l’operatore % è: "stringa di formato" % valori. La stringa di formato contiene segnaposti, come %s per le stringhe, che vengono sostituiti dai valori. Ad esempio, l’esempio seguente stampa “Ciao, Mark.”

'Hello %s' % 'Mark'

   'Hello Mark'

Altri specificatori di formato comuni sono mostrati nella tabella seguente.

Operatore % ha molte limitazioni. Per uno, è meno leggibile rispetto alle f-string. Considera il seguente codice.

name = "Alice"
age = 30
height = 5.6


# L'operatore % è difficile da analizzare
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Questo codice è chiaro a colpo d’occhio? Probabilmente no. C’è molta analisi visiva avanti e indietro dal segnaposto alle variabili che riempiono gli spazi vuoti. È facile confondersi (o sentirsi storditi) con tutto questo scambio di informazioni.

Ora, considera il codice equivalente utilizzando le f-string.

# Questo è molto più pulito
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Nessuna scansione e nessuna stringa di formattazione oscura sono richieste. Il codice è pulito, facile da capire e semplice da scrivere. Puoi imparare altri suggerimenti per scrivere codice chiaro e ottimizzato con il percorso di abilità di programmazione Python di DataCamp. 

Tecniche avanzate di interpolazione di stringhe Python

Ora che abbiamo compreso i concetti di base dell’interpolazione di stringhe in Python, diamo uno sguardo ad alcuni utilizzi più avanzati. 

Interpolazione di stringhe multilinea in Python

Le f-string possono anche essere utilizzate per contenuti multiriga utilizzando il segnaposto f con le virgolette triple (singole o doppie). Il testo può essere scritto su più righe e apparirà in output esattamente come formattato.

name = 'Mark'
profession = 'Astronaut'
age = 7


# Questo è un esempio di una stringa multiriga
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Le stringhe multilinea possono anche essere create utilizzando il .format() metodo.

name = 'Mark'
profession = 'Astronaut'
age = 7


# Questa è una stringa multilinea con .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Usi per l’interpolazione di stringhe multilinea

Perché dovresti voler usare l’interpolazione di stringhe multilinea? Ci sono molti usi per l’interpolazione di stringhe multilinea. Ecco alcuni casi d’uso:

• Generazione di email o messaggi multilinea
• Logging e debug
• Generazione dinamica di query SQL

Generazione di email o messaggi multilinea

Supponiamo che tu stia inviando una lettera di invito a molti partecipanti a una conferenza tecnologica.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event Team

Con le f-string, creare una lettera di invito è semplice ed efficiente. Per cambiare il nome, l’evento o la data, basta modificarli nelle variabili e la stringa cambia automaticamente.

Logging e debug

Le stringhe multilinea sono utili per stampare messaggi di errore nei log.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.

Questo metodo mantiene i messaggi di log strutturati e facilita il debug con log formattati correttamente.

Generazione dinamica di query SQL

Le query SQL possono essere costruite dinamicamente utilizzando stringhe multilinea.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

Questo metodo rende leggibili le query SQL e mantiene l’indentazione. Inoltre, elimina la necessità di utilizzare + per la concatenazione delle stringhe.

Altri casi d’uso includono:

• Scrittura di contratti formattati
• Creazione di documenti Markdown o $\LaTeX$
• Modelli HTML/XML multilinea
• Generazione di risposte API o testo simile a JSON

Vantaggi dell’interpolazione di stringhe multilinea

Come possiamo vedere, ci sono diversi vantaggi dell’interpolazione di stringhe multilinea.

• L’interpolazione di stringhe preserva la formattazione senza necessità del carattere di escape \n. 
• L’interpolazione di stringhe migliora la leggibilità rispetto alla formattazione su una singola riga. 
• L’interpolazione di stringhe riduce il disordine quando si lavora con testo strutturato (ad esempio, log, query, report). 
• L’interpolazione di stringhe consente la generazione dinamica di testo senza rompere l’indentazione.

Formattazione di numeri e valori speciali

Per controllare il numero di cifre decimali visualizzate utilizzando una stringa f, utilizzare la sintassi: f'{value:.nf}', dove value è il numero in virgola mobile, n è il numero di cifre decimali e f (quello dopo il .) sta per formattazione float.

Per illustrare, il seguente codice restituisce $\pi$ con diverse cifre decimali.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

La formattazione con il .format() metodo è simile.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

Puoi utilizzare una f-string per formattare le percentuali usando la sintassi :.nf combinata con %, dove n è il numero di cifre decimali.

score = 0.875
print(f"Success rate: {score:.2%}")

   Success rate: 87.50%

Puoi utilizzare una f-string per formattare la valuta utilizzando il :, per i separatori delle migliaia e .nf per controllare le cifre decimali. Puoi anche includere direttamente nel testo un simbolo di valuta come $, € o £.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

Utilizzando le f-string con dizionari e liste

Per utilizzare le f-string con un dizionario in Python, accedi ai valori del dizionario all’interno delle parentesi graffe utilizzando la notazione a parentesi quadre (dict[‘key’]) o scompattando il dizionario con **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")

   My name is Alice, I am 30 years old, and I live in New York.

Piuttosto che accedere manualmente a ogni chiave, puoi scompattare il dizionario in una f-string come segue.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))

   My name is Alice and I am 7 years old.

Per evitare un errore per chiavi mancanti, utilizza get() per accedere al dizionario.

person = {"name": "Alice"}


# Errore: manca la chiave 'city'
print(f"City: {person['city']}") 

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Errore: manca la chiave 'city'

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'

print(f"City: {person.get('city', 'Not specified')}")

   City: Not specified

Pro e Contro dei Metodi di Interpolazione di Stringhe

Come abbiamo visto, le f-string e il metodo .format() sono entrambi metodi utili per l’interpolazione di stringhe. Vediamo un confronto dei pro e dei contro di ciascun metodo.

Quando dovresti utilizzare .format() rispetto alle f-string?

Problemi comuni e pratiche consigliate

Di seguito, puoi trovare alcuni metodi di risoluzione dei problemi e i migliori consigli per l’uso dell’interpolazione delle stringhe in Python.

Evitare errori di sintassi con parentesi graffe.

Ci sono molti errori di sintassi che si possono commettere quando si utilizza l’interpolazione delle stringhe coinvolgendo le parentesi graffe.

• Assicurarsi che ogni { abbia una corrispondente }

print('Hello, my name is {name!'}

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('

Fortunatamente, l’errore è semplice e la correzione è facile.

• Usa {{ e }} per visualizzare le parentesi graffe letterali{}

Cosa succede se vuoi stampare parentesi graffe all’interno di una stringa interpolata? Qualsiasi cosa all’interno delle parentesi graffe sarà (tentata di) essere valutata.

print(f'Set notation: {a, b, c}')

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not defined

Python interpreta a, b, c all’interno delle parentesi graffe come una tupla, cercando di trovare un valore associato a a. Poiché non esiste alcuna variabile del genere, viene generato un KeyError. La correzione consiste nell’utilizzare le doppie parentesi graffe {{}}.

print("Set notation: {{a, b, c}}")

Notazione insiemistica: {{a, b, c}}

Confronto delle prestazioni: f-strings vs .format()

Confrontiamo le prestazioni delle f-strings e di .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Misura le prestazioni delle f-string
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Misura le prestazioni di .format()
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Misura le prestazioni delle f-string con espressioni
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Misura le prestazioni di .format() con espressioni
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Stampare i risultati
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Come puoi vedere, da un punto di vista dell’efficienza, si dovrebbero preferire le f-string a .format().

Pratiche consigliate per un’interpolazione di stringhe pulita e leggibile

Per assicurarti che la formattazione delle tue stringhe sia chiara, efficiente e manutenibile, segui queste pratiche consigliate nell’uso delle stringhe interpolate.

• Preferisci le f-string per la leggibilità (Python 3.6+)

# Consigliato
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Non consigliato (Meno leggibile)
print("My name is {} and I am {} years old.".format(name, age))


# Evita di utilizzare la formattazione con % (Obsoleta)
print("My name is %s and I am %d years old." % (name, age))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Utilizza segnaposti nominati per maggiore chiarezza

# Placeholder nominati (leggibili)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Utilizzo degli indici in .format() (meno leggibile)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Mantieni leggibili le stringhe multilinea.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  

• Utilizza le f-string nel Logging per un Miglior Debugging

Python 3.8 e versioni successive supportano = per il debugging nelle f-string.

value = 42


# Output: value = 42
print(f"{value = }") 

   value = 42

Conclusione

L’interpolazione di stringhe è una funzionalità potente in Python che rende la formattazione delle stringhe più pulita, leggibile ed efficiente. Tra i metodi disponibili, le f-string sono l’approccio più moderno e raccomandato, offrendo migliori prestazioni, chiarezza e flessibilità rispetto ai metodi più vecchi come .format() e % formatting. 

Seguendo le migliori pratiche, come l’uso di segnaposto nominati, il controllo della precisione decimale, l’allineamento del testo per una migliore leggibilità e la gestione elegante delle chiavi mancanti nel dizionario, è possibile scrivere formattazioni di stringhe pulite, professionali e manutenibili in Python.

Sia che si stiano generando report formattati, messaggi su più righe o output di dati strutturati, le f-string offrono un modo semplice ma potente per integrare variabili ed espressioni in modo trasparente. Abbracciare le f-string non solo migliorerà la qualità del tuo codice, ma ne aumenterà anche l’efficienza.

Per ulteriori informazioni sull’interpolazione di stringhe in Python, consulta le risorse di DataCamp:

• Formattazione f-string in Python tutorial
• Aggiunta di stringhe in Python: 6 tecniche essenziali di concatenazione
• Programmazione in Python percorso di competenze
• Fondamenti di Python percorso di competenze
• Introduzione alla Scienza dei Dati in Python corso