Introduzione
Quando si lavora con poche stringhe, quasi ogni tecnica di concatenazione sembra funzionare allo stesso modo. La situazione cambia però quando un programma deve costruire testi molto lunghi: file di log, report, query SQL, documenti HTML, esportazioni CSV o messaggi generati dinamicamente.
In Python le stringhe sono oggetti immutabili. Questo significa che, dopo la creazione, il contenuto di una stringa non può essere modificato direttamente. Ogni operazione che sembra aggiungere testo produce in realtà un nuovo oggetto stringa. Questa caratteristica è importante per comprendere le differenze di prestazioni tra l’operatore +, il metodo join(), le liste e io.StringIO.
In questo tutorial costruiremo un report testuale in tre modi diversi e vedremo quale tecnica scegliere in base al contesto. L’obiettivo non è ottimizzare prematuramente ogni riga di codice, ma imparare a riconoscere i casi in cui la costruzione delle stringhe può diventare un collo di bottiglia.
Codice completo
from io import StringIO
from time import perf_counter
righe = [
"Vendite gennaio: 1250 euro",
"Vendite febbraio: 1430 euro",
"Vendite marzo: 1610 euro",
]
def report_con_concatenazione(dati):
testo = "REPORT VENDITEn"
testo += "================n"
for riga in dati:
testo += riga + "n"
return testo
def report_con_join(dati):
parti = [
"REPORT VENDITE",
"================",
*dati,
]
return "n".join(parti) + "n"
def report_con_stringio(dati):
buffer = StringIO()
buffer.write("REPORT VENDITEn")
buffer.write("================n")
for riga in dati:
buffer.write(riga)
buffer.write("n")
return buffer.getvalue()
def misura(funzione, dati, ripetizioni=10000):
inizio = perf_counter()
for _ in range(ripetizioni):
funzione(dati)
fine = perf_counter()
return fine - inizio
if __name__ == "__main__":
print(report_con_concatenazione(righe))
print(report_con_join(righe))
print(report_con_stringio(righe))
print("Tempi di esempio:")
print("Concatenazione:", misura(report_con_concatenazione, righe))
print("join:", misura(report_con_join, righe))
print("StringIO:", misura(report_con_stringio, righe))
Spiegazione
Concatenazione con l’operatore +
L’operatore + è molto leggibile e va benissimo quando si uniscono poche stringhe:
nome = "Ada"
messaggio = "Ciao, " + nome + "!"
print(messaggio)
Nel caso di molte iterazioni, tuttavia, l’operazione può diventare costosa. A ogni aggiunta Python deve creare una nuova stringa contenente il risultato precedente più il nuovo testo. Con dati molto grandi, ciò può comportare numerose allocazioni di memoria e copie.
È importante non interpretare questa regola in modo assoluto: Python può applicare alcune ottimizzazioni interne e, per piccoli input, la differenza può essere irrilevante. Il problema emerge soprattutto quando il ciclo è lungo o il testo finale è molto voluminoso.
Costruzione con una lista e join()
Una soluzione comune consiste nel raccogliere i frammenti in una lista e unirli alla fine:
frammenti = []
for numero in range(1, 4):
frammenti.append(f"Riga {numero}")
testo = "n".join(frammenti)
print(testo)
Il metodo join() è particolarmente adatto perché conosce già tutti i frammenti da combinare e può costruire il risultato in modo più efficiente. Il separatore, in questo caso "n", viene inserito tra gli elementi, non dopo l’ultimo.
La sintassi generale è:
separatore.join(iterabile_di_stringhe)
Tutti gli elementi dell’iterabile devono essere stringhe. Se si possiedono numeri o altri oggetti, occorre convertirli esplicitamente:
valori = [10, 20, 30]
testo = ", ".join(str(valore) for valore in valori)
print(testo) # 10, 20, 30
Uso di io.StringIO
StringIO si comporta come un file aperto in memoria. È utile quando il testo viene prodotto progressivamente e non si vuole mantenere manualmente una lista di frammenti.
from io import StringIO
buffer = StringIO()
buffer.write("Prima rigan")
buffer.write("Seconda rigan")
risultato = buffer.getvalue()
print(risultato)
Questa tecnica è pratica nei generatori di report, nei serializer personalizzati e nei componenti che ricevono dati un blocco alla volta. Se il contenuto è destinato direttamente a un file, è spesso ancora meglio scrivere sul file invece di costruire tutto il testo in memoria:
righe = ["unon", "duen", "tren"]
with open("output.txt", "w", encoding="utf-8") as file:
file.writelines(righe)
Stringhe e generatori
Un generatore permette di produrre i frammenti solo quando servono, evitando di creare subito una lista completa:
def righe_report(n):
for indice in range(1, n + 1):
yield f"Elemento {indice}"
testo = "n".join(righe_report(5))
print(testo)
Il generatore riduce la memoria necessaria per preparare i dati. Tuttavia, join() deve comunque creare la stringa finale completa. Se il testo è enorme, la soluzione più scalabile è scrivere progressivamente su un file o su un altro flusso.
Best practice
- Usa
+per concatenazioni semplici e brevi, dove la leggibilità è prioritaria. - Usa
join()quando devi unire molti frammenti con un separatore. - Usa
StringIOquando costruisci un testo in più passaggi e preferisci un’interfaccia simile a quella dei file. - Per file molto grandi, scrivi progressivamente sul file invece di accumulare tutto in una singola stringa.
- Converti esplicitamente i valori non testuali con
str(), evitando errori durantejoin(). - Misura le prestazioni con dati realistici: un microbenchmark su tre righe non rappresenta necessariamente un caso di produzione.
- Non sacrificare la chiarezza per una differenza di velocità trascurabile. L’ottimizzazione deve risolvere un problema misurato.
- Specifica sempre
encoding="utf-8"quando apri file di testo, così il comportamento è più prevedibile tra sistemi diversi.
Riepilogo
La gestione efficiente delle stringhe dipende dal modo in cui il testo viene prodotto. La concatenazione con + è chiara e adatta a casi piccoli, mentre join() è generalmente preferibile quando si possiedono molti frammenti. StringIO offre un buffer testuale in memoria comodo per costruzioni progressive. Quando il contenuto è molto grande, conviene evitare di creare una stringa finale unica e utilizzare invece una scrittura a flusso.
La regola più utile è osservare il flusso dei dati: pochi frammenti richiedono semplicità, molti frammenti richiedono una strategia di aggregazione, dati enormi richiedono streaming.