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.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


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

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

Questo approccio è poco conciso e poco leggibile. Per fortuna, l'interpolazione di stringhe offre una soluzione migliore. Permette di inserire direttamente in una stringa variabili, espressioni o output di funzioni, rendendo la manipolazione delle stringhe dinamica ed eliminando la necessità di concatenazioni manuali.

Usando l'interpolazione di stringhe, potremmo riscrivere il codice come segue.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


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

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

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

Interpolazione di stringhe di base in Python

In Python sono disponibili diverse tecniche di interpolazione di stringhe. Il metodo più consigliato è quello dei letterali di stringa formattati, noti anche come f-string, disponibili da Python 3.6.

Un altro metodo, comune nel codice precedente a Python 3.6, è il metodo .format(). Anche se è più verboso delle f-string, a volte presenta dei vantaggi (dettagli sotto).

Infine, potresti imbatterti nella formattazione in stile % nel codice legacy.

Uso delle f-string (Python 3.6+)

Le f-string (formatted string literals) sono un modo potente e conciso per formattare le stringhe in Python. Introdotte in Python 3.6, offrono un modo leggibile ed efficiente per inserire variabili, espressioni e chiamate di funzione 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)Offerto da

   My name is Mark.Offerto da

In questo codice, la variabile output_string viene assegnata a una f-string. Il prefisso f prima dell'apice di apertura indica che la stringa supporta espressioni incorporate. La variabile name viene valutata e il suo valore inserito nella stringa, producendo l'output: "My name is 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


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Offerto da

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

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

Uso del metodo .format()

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

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

   My name is Mark.Offerto da

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

Argomenti posizionali

Cosa succede se ti servono più segnaposto per più variabili? Considera il seguente codice.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Offerto da

   My name is Mark and I am 7 years old.Offerto da

In questo esempio servono due variabili, name e age. Di conseguenza, la stringa include due segnaposto e le variabili sono inserite nello stesso ordine in cui compaiono nel metodo .format(). Questi argomenti sono detti *posizionali* perché il loro inserimento nella stringa è determinato dalla posizione nella lista di argomenti del metodo.

Segnaposto indicizzati e nominali

Come variazione dell'idea dei segnaposto, considera questo esempio.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Offerto da

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

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

name = 'Mark'
age = 7


# Use indexed placeholders
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)Offerto da

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

In questo esempio abbiamo definito esplicitamente l'ordine delle variabili tra parentesi graffe, seguendo l'indicizzazione a partire da zero di Python. Inoltre, abbiamo riutilizzato la variabile all'indice 1 invece di ripeterla.

In alternativa all'indicizzazione posizionale, puoi usare anche argomenti nominali, assegnando un nome a ciascun argomento.

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

   My name is Mark and I am 7 years old.Offerto da

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

Uso dell'operatore %

L'ultimo metodo per l'interpolazione di stringhe è l'operatore %. Funziona in modo simile al comando printf() in C. Il suo uso è deprecato ed è fortemente sconsigliato a favore delle f-string o del metodo .format(). Lo citiamo qui perché potresti incontrarlo in codebase legacy.

Il formato di base per l'operatore % è: "format string" % values. La stringa di formato contiene segnaposto, come %s per le stringhe, che vengono sostituiti dai valori. Ad esempio, il seguente esempio stampa "Hello, Mark."

'Hello %s' % 'Mark'Offerto da

   'Hello Mark'Offerto da

Altri specificatori di formato comuni sono mostrati nella tabella seguente.

L'operatore % ha molte limitazioni. Per cominciare, è meno leggibile delle f-string. Considera il seguente codice.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Offerto da

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

Questo codice è chiaro a colpo d'occhio? Probabilmente no. C'è molto lavoro visivo di andata e ritorno tra i segnaposto e le variabili che li riempiono. È facile confondersi (o farsi venire il capogiro) con tutto quello scanning avanti e indietro.

Ora considera un codice equivalente che usa le f-string.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Offerto da

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

Non sono richiesti né scanning né stringhe di formattazione oscure. Il codice è pulito, facile da capire e da scrivere. Puoi imparare altri consigli per scrivere codice chiaro e ottimizzato con lo skill track di DataCamp su Python Programming. 

Tecniche avanzate di interpolazione di stringhe in Python

Ora che abbiamo capito le basi dell'interpolazione di stringhe in Python, vediamo alcuni usi più avanzati. 

Interpolazione multilinea di stringhe in Python

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

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


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Offerto da

   Name: Mark

   Profession: Astronaut

   Age: 7Offerto da

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

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


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Offerto da

   Name: Mark

   Profession: Astronaut

   Age: 7Offerto da

Casi d'uso per l'interpolazione multilinea

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

• Generare email o messaggi multilinea
• Logging e debugging
• Generare query SQL in modo dinamico

Generare email o messaggi multilinea

Supponiamo che tu stia inviando una lettera standard a molti invitati a una conferenza tech.

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)Offerto da

   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 TeamOfferto da

Con le f-string, creare una lettera standard è semplice ed efficiente. Per cambiare nome, evento o data, ti basta aggiornare le variabili e la stringa cambia in automatico.

Logging e debugging

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)Offerto da

   [ERROR 404]

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

   URL: /missing-page

 

   The requested page could not be found.Offerto da

Questo metodo mantiene strutturati i messaggi di log e rende il debugging più facile grazie a log ben formattati.

Generare query SQL in modo dinamico

Le query SQL possono essere costruite dinamicamente usando stringhe multilinea.

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


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


print(query)Offerto da

   SELECT *

   FROM users

   WHERE email = '[email protected]';Offerto da

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

Altri casi d'uso includono:

• Scrittura di contratti formattati
• Creazione di documenti Markdown o $\LaTeX$
• Template HTML/XML multilinea
• Generazione di risposte API o testo in stile JSON

Vantaggi dell'interpolazione multilinea

Come possiamo vedere, ci sono diversi vantaggi dell'interpolazione multilinea.

• L'interpolazione di stringhe preserva la formattazione senza dover usare il carattere di escape \n. 
• L'interpolazione di stringhe migliora la leggibilità rispetto alla formattazione su singola riga. 
• L'interpolazione di stringhe riduce il disordine quando lavori con testo strutturato (per esempio log, query, report). 
• L'interpolazione di stringhe permette di generare testo dinamico senza rompere l'indentazione. 

Formattazione di numeri e valori speciali

Per controllare il numero di cifre decimali mostrate usando una f-string, usa la sintassi: f'{value:.nf}', dove value è il numero in virgola mobile, n è il numero di cifre decimali e f (quello dopo il .) indica la formattazione float.

Per illustrare, il codice seguente stampa $\pi$ con un numero diverso di 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}')Offerto da

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

La formattazione con il metodo .format() è 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))Offerto da

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

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

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

   Success rate: 87.50%Offerto da

Puoi usare una f-string per formattare valute usando :, per i separatori delle migliaia e .nf per controllare le cifre decimali. Puoi anche includere direttamente nella stringa un simbolo di valuta come $, € o £.

amount = 98765.4321


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

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Offerto da

Uso delle f-string con dizionari e liste

Per usare le f-string con un dizionario in Python, accedi ai valori del dizionario tra parentesi graffe usando la notazione con parentesi quadre (dict['key']) o effettuando l'unpacking del 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']}.")Offerto da

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

Invece di accedere manualmente a ciascuna chiave, puoi fare l'unpacking del 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))Offerto da

   My name is Alice and I am 7 years old.Offerto da

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

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Offerto da

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Error: key 'city' is missing

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







   KeyError: 'city'Offerto da

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

   City: Not specifiedOfferto da

Pro e contro dei metodi di interpolazione

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

Quando dovresti usare .format() invece delle f-string?

Errori comuni e buone pratiche

Di seguito trovi alcuni metodi di troubleshooting e consigli per usare al meglio l'interpolazione di stringhe in Python. 

Evitare errori di sintassi con le parentesi graffe

Ci sono molti errori di sintassi in cui si può incorrere usando l'interpolazione con parentesi graffe.

• Assicurati che ogni { abbia una } corrispondente

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

     Cell In[96], line 1

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

Per fortuna, l'errore è chiaro e la correzione è semplice.

• Usa {{ e }} per mostrare letteralmente {}

Cosa succede se vuoi stampare parentesi graffe all'interno di una stringa interpolata? Qualsiasi cosa tra parentesi graffe verrà (tentata di essere) valutata.

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

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

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

   NameError: name 'c' is not definedOfferto da

Python interpreta a, b, c tra parentesi graffe come una tupla, cercando di trovare un valore associato ad a. Poiché tale variabile non esiste, solleva un KeyError. La correzione è usare doppie parentesi graffe {{}}.

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

   Set notation: {{a, b, c}}

Confronto prestazionale: f-string vs .format()

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

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


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


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


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
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")Offerto da

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsOfferto da

Come puoi vedere, dal punto di vista dell'efficienza, è preferibile usare le f-string rispetto a .format().

Buone pratiche per un'interpolazione pulita e leggibile

Per garantire che la tua formattazione sia chiara, efficiente e manutenibile, segui queste buone pratiche quando usi stringhe interpolate.

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

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


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Offerto da

   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.Offerto da

• Usa segnaposto nominali per maggiore chiarezza

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


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Offerto da

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Offerto da

• 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)Offerto da

   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  Offerto da

• Usa le f-string nel logging per un debugging migliore

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

value = 42


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

   value = 42Offerto da

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 prestazioni, chiarezza e flessibilità migliori rispetto a metodi più vecchi come .format() e la formattazione con %. 

Seguendo le buone pratiche, come usare segnaposto nominali, controllare la precisione decimale, allineare il testo per la leggibilità e gestire con grazia le chiavi mancanti nei dizionari, puoi scrivere formattazioni di stringhe pulite, professionali e manutenibili in Python. 

Che tu stia generando report formattati, messaggi multilinea o output di dati strutturati, le f-string offrono un modo semplice ma potente per integrare senza sforzo variabili ed espressioni. 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, dai un'occhiata alle risorse di DataCamp:

• f-string Formatting in Python tutorial
• Python Append String: 6 Essential Concatenation Techniques
• Python Programming skill track
• Python Fundamentals skill track
• Introduction to Data Science in Python course