Come convertire una stringa in byte in Python

Le stringhe rappresentano testo leggibile dalle persone e sono uno dei tipi di dati più basilari e importanti nella programmazione. Tuttavia, ogni carattere in una stringa di testo è rappresentato da uno o più byte di dati binari. Applicazioni come le operazioni di input e output e la trasmissione dei dati richiedono che le stringhe vengano convertite in byte usando una codifica specifica.

Questo tutorial esplora le tecniche per convertire le stringhe in byte in Python. Se ti interessa l'operazione inversa, dai un'occhiata al mio tutorial su come convertire i byte in stringhe in Python.

Prima di entrare nei dettagli, iniziamo con una risposta breve per chi ha fretta.

Risposta breve: come convertire una stringa in byte in Python

Python rende semplice convertire una stringa in byte usando il metodo integrato .encode():

my_string = "Hello, world!"
bytes_representation = my_string.encode(encoding="utf-8")  
# Optional: Specify the desired encoding (UTF-8 is the default)

print(bytes_representation)
# Output: b'Hello, world!'Offerto da

Il metodo .encode() restituisce un nuovo oggetto bytes che rappresenta la versione codificata della stringa originale. Per impostazione predefinita usa la codifica UTF-8, ma se necessario puoi specificare altre codifiche come 'ascii' o 'latin-1'.

Esploriamo ora questo processo di conversione più nel dettaglio.

Capire stringhe e byte in Python

Due dei tipi di dati integrati fondamentali in Python sono str e bytes. Questi tipi condividono alcune caratteristiche ma hanno differenze chiave.

Sia str che bytes sono sequenze immutabili, il che significa che non possiamo modificarne gli elementi dopo la creazione. Una stringa è una sequenza immutabile di caratteri, mentre un oggetto bytes è una sequenza immutabile di interi tra 0 e 255. Questo intervallo di interi può essere rappresentato da 8 bit, ossia un byte. Pertanto, un oggetto bytes è una sequenza di byte.

Codifica dei caratteri ASCII

Consideriamo prima i caratteri ASCII. ASCII (American Standard Code for Information Interchange) è una codifica di caratteri che contiene solo 128 caratteri. Di conseguenza, qualsiasi carattere ASCII può essere rappresentato da sette bit, quindi meno di un singolo byte.

Possiamo creare un oggetto bytes aggiungendo una b davanti alle virgolette singole, doppie o triple che usiamo normalmente per le stringhe:

word_as_bytes = b"Python"
print(word_as_bytes)
print(type(word_as_bytes))Offerto da

b'Python'
<class 'bytes'>Offerto da

Anche se il codice mostra i caratteri della parola Python, ogni elemento dell'oggetto bytes è un intero tra 0 e 255:

print(word_as_bytes[0])
print(list(word_as_bytes))Offerto da

80
[80, 121, 116, 104, 111, 110]Offerto da

Il primo elemento di word_as_bytes è l'intero 80, che è il codice ASCII per la P maiuscola:

print(chr(80))Offerto da

POfferto da

Quando convertiamo word_as_bytes in una lista, la lista contiene gli interi che rappresentano ciascun byte. Gli interi sono i codici ASCII delle lettere nella parola Python.

Tuttavia, il set di caratteri ASCII è limitato.

Codifica dei caratteri UTF-8

La codifica di caratteri più comune è UTF-8, una codifica Unicode a 8 bit. I 128 caratteri ASCII sono rappresentati dagli stessi interi in UTF-8, ma anche altri caratteri possono essere rappresentati usando due o più byte per ciascun carattere.

Creiamo un oggetto bytes usando caratteri non ASCII. In questo caso dobbiamo usare il costruttore bytes():

word_as_bytes = bytes("café", "utf-8")
print(word_as_bytes)Offerto da

b'caf\xc3\xa9'Offerto da

L'oggetto bytes mostra direttamente le prime tre lettere di café. Tuttavia, la é accentata non è un carattere ASCII ed è rappresentata da due byte, visualizzati come \xc3 e \xa9. Questi byte rappresentano i numeri esadecimali c3 e a9, che corrispondono agli interi 195 e 169. Questi due byte insieme rappresentano é in UTF-8:

print(len(word_as_bytes))
print(list(word_as_bytes))Offerto da

5
[99, 97, 102, 195, 169]Offerto da

Un oggetto bytes di cinque elementi rappresenta la stringa di quattro lettere.

Conversione da stringhe a byte: il metodo encode()

In precedenza abbiamo usato il costruttore bytes() per convertire una stringa di testo in un oggetto bytes. Un modo più comune per convertire stringhe Python in byte è usare il metodo di stringa .encode(), che offre controllo sulla codifica e sulla gestione degli errori. Questo metodo restituisce un oggetto bytes che rappresenta la stringa:

word_as_bytes = "Hello Python!".encode()
​print(word_as_bytes)
print(type(word_as_bytes))
Offerto da

b'Hello Python!'
<class 'bytes'>Offerto da

Il metodo .encode() usa come predefinita la codifica UTF-8. UTF-8 è il formato di codifica più diffuso e supporta un insieme di caratteri molto più ampio rispetto ad ASCII. UTF-8 rappresenta ogni carattere con una sequenza di unità da uno, due, tre o quattro byte.

Possiamo chiamare .encode() passando un'altra codifica come argomento:

word_as_bytes = "Hello Python!".encode("utf-16")
print(word_as_bytes)Offerto da

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00 \x00P\x00y\x00t\x00h\x00o\x00n\x00!\x00'Offerto da

In questo caso l'oggetto bytes è diverso, perché rappresenta la codifica UTF-16 della stessa stringa di testo.

Errori di codifica

Poiché non tutte le codifiche includono tutti i caratteri, possono verificarsi errori quando si codifica una stringa in un oggetto bytes.

Consideriamo la stringa "Café • £2.20", che contiene tre caratteri non ASCII. Possiamo codificarla usando la codifica predefinita UTF-8:

word_as_bytes = "Café • £2.20".encode()
print(word_as_bytes)Offerto da

b'Caf\xc3\xa9 \xe2\x80\xa2 \xc2\xa32.20'Offerto da

I caratteri non ASCII vengono sostituiti dalle loro sequenze di escape esadecimali. Tuttavia, .encode() solleva un errore se la stessa stringa viene codificata usando ASCII, dato che diversi caratteri non sono presenti nella codifica ASCII:

word_as_bytes = "Café • £2.20".encode("ascii")
print(word_as_bytes)Offerto da

Traceback (most recent call last):
...
word_as_bytes = "Café • £2.20".encode("ascii")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3: ordinal not in range(128)Offerto da

Il metodo di stringa .encode() ha un parametro errors, che ha valore predefinito "strict". L'argomento "strict" impone a .encode() di sollevare un UnicodeEncodeError quando un carattere non può essere codificato.

Esistono però altre opzioni per gestire gli errori. Una possibilità è ignorare gli errori usando l'argomento "ignore":

word_as_bytes = "Café • £2.20".encode("ascii", errors="ignore")
print(word_as_bytes)Offerto da

b'Caf 2.20'Offerto da

Questa opzione non solleva un errore. Al contrario, .encode() restituisce un oggetto bytes, e la é accentata, il punto elenco e il simbolo della sterlina vengono omessi.

Un'altra opzione è sostituire i caratteri che non possono essere codificati con qualcos'altro. Esistono diverse opzioni di sostituzione. Una di queste è l'argomento errors="replace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="replace")
print(word_as_bytes)Offerto da

b'Caf? ? ?2.20'Offerto da

I tre caratteri non ASCII, che in questo esempio non possono essere codificati, vengono sostituiti con un punto interrogativo. Quindi ogni carattere mancante viene rimpiazzato da un altro singolo carattere che funge da segnaposto.

Possiamo anche sostituire i caratteri mancanti con testo più informativo:

word_as_bytes = "Café • £2.20".encode("ascii", errors="backslashreplace")
print(word_as_bytes)Offerto da

b'Caf\\xe9 \\u2022 \\xa32.20'Offerto da

Chiamare .encode() con errors="backslashreplace" sostituisce i caratteri che non possono essere codificati con le loro sequenze di escape esadecimali. Il numero esadecimale e9 rappresenta la é accentata. Il punto elenco è il carattere Unicode u2022 e il numero esadecimale a3 rappresenta il simbolo della sterlina.

Possiamo anche usare "xmlcharrefreplace" per sostituire i caratteri mancanti con il loro codice XML:

word_as_bytes = "Café • £2.20".encode("ascii", errors="xmlcharrefreplace")
print(word_as_bytes)Offerto da

b'Café • £2.20'Offerto da

Un'altra opzione è sostituire i caratteri non validi con il loro nome formale usando errors="namereplace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="namereplace")
print(word_as_bytes)Offerto da

b'Caf\\N{LATIN SMALL LETTER E WITH ACUTE} \\N{BULLET} \\N{POUND SIGN}2.20'Offerto da

Situazioni diverse possono richiedere una gestione degli errori su misura, e il metodo di stringa .encode() offre varie opzioni per trattare i caratteri che non possono essere codificati.

Applicazioni della conversione da stringa a byte nella data science

La conversione da stringa a byte è un'operazione fondamentale che trova applicazione in vari ambiti della data science:

• Elaborazione del linguaggio naturale (NLP): Quando si lavora con dati testuali per attività come analisi del sentiment, topic modeling o traduzione automatica, spesso si preelabora il testo tokenizzandolo in parole o sottoparole. Questo processo di tokenizzazione coinvolge frequentemente la conversione delle stringhe in sequenze di byte per una rappresentazione e manipolazione efficienti.
• Pulizia e preelaborazione dei dati: Le operazioni a livello di byte possono essere utili per ripulire i dati testuali, ad esempio rimuovendo caratteri non validi o normalizzando il testo in base a specifici pattern di byte.
• Feature engineering: In alcuni casi, caratteristiche a livello di byte (ad esempio, n-grammi di byte) possono essere estratte dai dati testuali e usate come feature di input per modelli di machine learning.
• Web scraping ed estrazione dei dati: Quando si eseguono scraping di dati dai siti web, spesso si ricevono contenuti HTML o altri contenuti testuali che potrebbero dover essere analizzati e processati a livello di byte per estrarre le informazioni rilevanti.
• Compressione dei dati: Alcuni algoritmi di compressione operano su sequenze di byte, quindi convertire le stringhe in byte può essere un passaggio necessario prima di applicare tecniche di compressione.

Capire queste applicazioni può aiutarti a individuare le situazioni in cui può essere utile convertire le stringhe in byte.

Conclusione

Le stringhe sono sequenze di caratteri leggibili dalle persone. Questi caratteri sono codificati come byte di dati binari, che possono essere memorizzati in un oggetto bytes. Un oggetto bytes è una sequenza di interi e ogni intero rappresenta un byte.

Le applicazioni richiedono che le stringhe vengano convertite in oggetti bytes, conversione che possiamo effettuare sia con il costruttore bytes() sia con il metodo di stringa .encode(). Padroneggiare la conversione tra stringhe e byte consente una manipolazione dei dati più flessibile.

Puoi proseguire il tuo apprendimento di Python con i seguenti tutorial e corsi:

• Corso Introduction to Python
• Python Programming
• Python Fundamentals