Ciao a tutti! Nell’articolo di oggi, vedremo come usare il modulo IO di Python.
Questo modulo è abbastanza utile quando si vogliono eseguire operazioni di I/O relative ai file (es. lettura/scrittura di file)
Mentre si possono usare i normali metodi read() e write() per leggere/scrivere su un file, questo modulo ci dà molta più flessibilità riguardo a queste operazioni.
Per capire meglio questo modulo, facciamo qualche esempio.
Modulo IO di Python
Questo modulo fa parte della libreria standard, quindi non è necessario installarlo separatamente usando pip.
Per importare il modulo io, possiamo fare quanto segue:
import io
Nel modulo io ci sono 2 classi comuni che sono molto utili per noi:
- BytesIO -> operazioni di I/O su dati byte
- StringIO -> operazioni di I/O su dati stringa
Possiamo accedere a queste classi usando io.BytesIO e io.StringIO.
Guardiamoli uno per uno.
Classe BytesIO di Python
Qui, possiamo tenere i nostri dati sotto forma di byte (b''). Quando usiamo io.BytesIO, i dati sono tenuti in un buffer in-memory.
Possiamo ottenere un’istanza del flusso di byte usando il costruttore:
import iobytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')
Notare che stiamo passando una stringa di byte (con prefisso b).
In questo momento, bytes_stream è semplicemente un handle al flusso di byte.
Per stampare effettivamente i dati all’interno del buffer, dobbiamo usare bytes_stream.getvalue().
import iobytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')print(bytes_stream.getvalue())
Qui, getvalue() prende il valore della stringa di byte dall’handle.
Siccome la stringa di byte \x0A è la rappresentazione ASCII del newline (‘\n’), otteniamo il seguente output:
Output
b'Hello from Journaldev\nHow are you?'
Ora, è sempre una buona pratica chiudere il nostro buffer handle quando abbiamo finito il nostro lavoro.
Questo serve anche per essere sicuri di liberare la memoria che abbiamo allocato per il buffer.
Per chiudere il buffer, usate:
bytes_stream.close()
Ora vediamo la classe StringIO.
Classe StringIO di Python
Simile a io.BytesIO, la classe io.StringIO può leggere dati relativi a stringhe da un buffer StringIO.
import iostring_stream = io.StringIO("Hello from Journaldev\nHow are you?")
Possiamo leggere dal buffer di stringhe usando string_stream.read() e scrivere usando string_stream.write(). Questo è molto simile alla lettura/scrittura da un file!
Possiamo stampare il contenuto usando getvalue().
Output
Initially, buffer: Hello from JournaldevHow are you?Finally, buffer: This will overwrite the old content of the buffer if the length of this string exceeds the old content
Siccome stiamo scrivendo sullo stesso buffer, il nuovo contenuto sovrascriverà ovviamente quello vecchio!
Leggere da un buffer StringIO
Similmente alla scrittura, possiamo anche leggere da un buffer StringIO usando buffer.read().
import ioinput = io.StringIO('This goes into the read buffer.')print(input.read())
Output
This goes into the read buffer.
Come potete vedere, il contenuto è ora dentro il buffer di lettura, che viene stampato usando buffer.read().
Leggere un file usando io
Possiamo usare il metodo io.open() anche per leggere direttamente da un file, in modo simile alla lettura da un oggetto file.
Qui, questo modulo ci dà la possibilità di scegliere tra lettura buffered e non-buffered.
Per esempio, il seguente userà una lettura buffered per leggere un file, impostando buffering = SIZE. Se SIZE = 0, questo implicherà nessun buffering!
Supponiamo che sample.txt abbia il seguente contenuto:
Hello from JournalDev!How are you?This is the last line.
Output
b'Hello from JournalDev!\nHow are you?\nThis is the last line.\n'
Come potete vedere, il file è stato letto con successo! Qui, io leggerà il file usando un buffer di circa 5 byte.
Usando io.open() vs os.open()
La funzione io.open() è un modo molto preferito per eseguire operazioni di I/O in quanto è fatta come un’interfaccia pitonica di alto livello.
Al contrario, la os.open() eseguirà una chiamata di sistema alla funzione open(). Questo restituirà un descrittore di file, che non può essere usato come l’oggetto io handle.
Siccome io.open() è una funzione wrapper per os.open(), è generalmente una buona pratica usare tali funzioni wrapper, poiché gestiscono automaticamente molti errori per voi.
Conclusione
In questo articolo, abbiamo imparato ad usare il modulo IO di Python, e le sue due classi principali – io.BytesIO e io.StringIO per leggere e scrivere byte e stringhe in un buffer.