Python f-Strings

Le f-string (letterali di stringa formattati) sono state introdotte in Python 3.6 e sono ora il metodo consigliato per incorporare valori all'interno delle stringhe. Sono più veloci della formattazione con % e di str.format(), e molto più leggibili perché il nome della variabile si trova direttamente all'interno della stringa nel punto in cui apparirà.

Questo capitolo tratta:

• La sintassi di base delle f-string e come incorporare variabili
• La valutazione di espressioni, chiamate a metodi e chiamate a funzioni inline
• Specificatori di formato: allineamento, larghezza, precisione e basi numeriche
• La formattazione delle date e l'uso degli specificatori di segno e zero-padding
• Lo specificatore di debug = (Python 3.8+)
• Le f-string multiriga e i template riutilizzabili nelle funzioni
• Problemi comuni e come evitarli

Capitoli correlati: Stringhe di formato · Formattazione delle stringhe in Python · Stringhe in Python · Date in Python · Regex in Python

Sintassi di base

Una f-string è qualsiasi letterale di stringa che inizia con la lettera f (o F) immediatamente prima della virgoletta di apertura. Qualsiasi espressione Python inserita tra le parentesi graffe {} viene valutata a runtime e il suo valore viene convertito in una stringa e inserito nel risultato.

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

My name is Alice and I am 30 years old.

Il prefisso f funziona con virgolette singole, doppie e triple:

language = "Python"
print(f'I love {language}!')          # single quotes
print(f"""I love {language}!""")      # triple quotes

I love Python!
I love Python!

Incorporare espressioni

Il segnaposto {} accetta qualsiasi espressione Python valida — non solo nomi di variabili. È possibile eseguire operazioni aritmetiche, confronti, chiamare metodi, chiamare funzioni e accedere alle chiavi di un dizionario.

Aritmetica e confronti

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")
print(f"The square of {x} is {x ** 2}")
print(f"Is {x} greater than {y}? {x > y}")

10 divided by 3 is 3.33
The square of 10 is 100
Is 10 greater than 3? True

Chiamate a metodi

name = "alice smith"
print(f"Hello, {name.title()}!")
print(f"Uppercase: {name.upper()}")

Hello, Alice Smith!
Uppercase: ALICE SMITH

Chiamate a funzioni e built-in

items = ["apples", "bananas", "cherries"]
print(f"You have {len(items)} items in the list.")

You have 3 items in the list.

Accesso al dizionario

Utilizzare virgolette singole all'interno delle parentesi graffe per accedere alle chiavi del dizionario (la stringa esterna usa virgolette doppie, quindi non ci sono conflitti):

person = {"name": "Bob", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")

Name: Bob, Age: 25

Espressioni condizionali

score = 72
print(f"Score: {score} => {'Pass' if score >= 60 else 'Fail'}")

Score: 72 => Pass

Specificatori di formato

Dopo l'espressione, aggiungere i due punti : seguiti da uno specificatore di formato per controllare l'aspetto del valore. La sintassi completa del mini-linguaggio è:

{expression:[fill][align][sign][width][grouping][.precision][type]}

Non è necessario utilizzare ogni parte — combina solo le parti di cui hai bisogno.

Allineamento e larghezza

Usare < (sinistra), > (destra) o ^ (centro) con un numero per impostare la larghezza del campo:

name = "Alice"
print(f"|{name:<10}|")   # left-align in a field of width 10
print(f"|{name:>10}|")   # right-align
print(f"|{name:^10}|")   # center

|Alice     |
|     Alice|
|  Alice   |

Specificare un carattere di riempimento prima del simbolo di allineamento per riempire con qualcosa di diverso dagli spazi:

print(f"|{'hello':*^15}|")  # fill with * and center

|*****hello*****|

Precisione decimale

pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")   # 2 decimal places
print(f"Pi is approximately {pi:.4f}")   # 4 decimal places

Pi is approximately 3.14
Pi is approximately 3.1416

Formattazione dei numeri

price = 1234567.89
print(f"{price:,.2f}")   # comma as thousands separator
print(f"{price:e}")      # scientific notation

1,234,567.89
1.234568e+06

Visualizzare un valore come percentuale direttamente — Python moltiplica per 100 automaticamente:

ratio = 0.853
print(f"{ratio:.1%}")

85.3%

Specificatore di segno

Usare + per mostrare sempre il segno, o uno spazio per riservare uno spazio ai numeri positivi (in modo che le colonne si allineino con quelle negative):

x = 42
y = -7
print(f"{x:+d}")    # +42
print(f"{y:+d}")    # -7
print(f"{x: d}")    # space before positive
print(f"{y: d}")    # -7

+42
-7
 42
-7

Zero-padding

Riempire un intero a una larghezza fissa con zeri iniziali usando 0 prima del numero di larghezza:

print(f"{42:010d}")   # zero-pad to 10 digits

0000000042

Combinare segno e zero-padding — il segno occupa la prima posizione:

x = 42
print(f"{x:+010d}")   # +000000042

+000000042

Basi degli interi

x = 255
print(f"{x:d}")    # decimal   -> 255
print(f"{x:x}")    # hex lower -> ff
print(f"{x:X}")    # hex upper -> FF
print(f"{x:o}")    # octal     -> 377
print(f"{x:b}")    # binary    -> 11111111

255
ff
FF
377
11111111

Formattazione delle date

Quando si inserisce un oggetto datetime o date all'interno di una f-string, è possibile seguire i due punti con i codici di formato strftime per controllare l'output direttamente — senza bisogno di chiamare .strftime():

from datetime import date
today = date(2024, 6, 19)
print(f"Today is {today:%B %d, %Y}")
print(f"ISO format: {today:%Y-%m-%d}")

Today is June 19, 2024
ISO format: 2024-06-19

Consulta il capitolo Date in Python per l'elenco completo dei codici di formato strftime.

Lo specificatore di debug = (Python 3.8+)

Aggiungendo = dopo il nome dell'espressione, vengono stampati sia il testo dell'espressione che il suo valore. Questo evita di dover digitare due volte il nome della variabile ed è prezioso per il debug rapido:

val = 42
result = val * 2
print(f"{val=}, {result=}")

val=42, result=84

I valori string ricevono il trattamento repr() in modo da poter vedere le virgolette:

name = "Alice"
print(f"{name=}")

name='Alice'

È possibile combinare = con uno specificatore di formato — inserire lo specificatore dopo =:

pi = 3.14159265
print(f"{pi=:.3f}")

pi=3.142

F-string multiriga

Per testi più lunghi è possibile estendere una f-string su più righe. Due approcci funzionano bene.

Concatenazione implicita di stringhe (nessuna barra rovesciata necessaria all'interno delle parentesi):

name = "Alice"
age = 30
city = "London"
profile = (
    f"Name : {name}\n"
    f"Age  : {age}\n"
    f"City : {city}"
)
print(profile)

Name : Alice
Age  : 30
City : London

F-string con virgolette triple — le nuove righe sono letterali, quindi non è necessario \n:

name = "Alice"
age = 30
report = f"""
Name : {name}
Age  : {age}
""".strip()
print(report)

Name : Alice
Age  : 30

Template riutilizzabili

Le f-string vengono valutate immediatamente, quindi non è possibile memorizzarle come variabile di template e riempirle in seguito. Usare invece una funzione:

def greet(name, role):
    return f"Hello, {name}! Your role is {role}."

print(greet("Alice", "admin"))
print(greet("Bob", "editor"))

Hello, Alice! Your role is admin.
Hello, Bob! Your role is editor.

Se hai davvero bisogno di un template differito, usa str.format() — consulta Stringhe di formato.

Parentesi graffe letterali nell'output

Per includere un carattere { o } letterale nell'output, raddoppiarlo:

value = 42
print(f"The answer is {{value}} = {value}")

The answer is {value} = 42

Problemi comuni

Barre rovesciate all'interno dell'espressione (Python < 3.12)

Prima di Python 3.12, una barra rovesciata non è consentita all'interno dell'espressione {} di una f-string. La soluzione è calcolare il valore in una variabile prima:

items = ["a", "b", "c"]

# This raises SyntaxError on Python < 3.12:
# print(f"{'\n'.join(items)}")

# Workaround — pre-compute:
joined = "\n".join(items)
print(f"Items:\n{joined}")

Items:
a
b
c

Python 3.12 ha rimosso questa restrizione, quindi le barre rovesciate sono ora valide all'interno delle espressioni f-string.

Usare lo stesso tipo di virgolette all'interno dell'espressione

Se la f-string esterna usa virgolette doppie, usare virgolette singole per le chiavi del dizionario all'interno di {}. Se si ha bisogno dello stesso tipo di virgolette, cambiare le virgolette esterne o usare una variabile:

person = {"name": "Bob"}

# Works — single quotes inside double-quoted f-string
print(f"Name: {person['name']}")

# Also works — pre-assign the key
key = "name"
print(f"Name: {person[key]}")

Name: Bob
Name: Bob

Le f-string non sono lazy

Una f-string valuta ogni espressione nel momento in cui la riga viene eseguita. Se si assegna una f-string a una variabile, essa cattura i valori correnti — modificare le variabili in seguito non ha alcun effetto sulla stringa già valutata:

x = 5
msg = f"x is {x}"
x = 99
print(msg)   # still shows 5, not 99

x is 5

Usare una funzione (come mostrato sopra) quando si ha bisogno di un template che venga valutato in seguito.

Riferimento rapido

Esercitazione