bancaldo™

Torna all’indice degli appunti

QFile

La classe QFile mette a disposizione un’interfaccia per la lattura da file e la scrittura su file.
Il nome del file si può passare direttamente al costruttore, o è possibile settarlo in seguito con il metodo setFileName(finename).

>>> from PyQt5.QtCore import QFile
>>> f = QFile("C:/temp/test.txt")

L’esistenza di un file è verificabile con il metodo exists():

>>> f.exists()
True

OPEN FILE

Un file viene aperto con il metodo open(mode), dove mode è un enum QIODevice che indica appunto, in che modo il device è stato aperto e può assumere i seguenti valori:

Costante	Valore	Descrizione
QIODevice.NotOpen	0x0000	il dispoditivo non è aperto
QIODevice.ReadOnly	0x0001	il dispositivo è aperto in lettura
QIODevice.WriteOnly	0x0002	il dispositivo è aperto in scrittura
QIODevice.ReadWrite	ReadOnly | WriteOnly	Il dispositivo è aperto in lettura e scrittura
QIODevice.Append	0x0004	Il dispositivo è aperto in append mode, tutti i dati sono scritti alla fine del file
QIODevice.Truncate	0x0008	Se possibile, il dispositivo viene troncato prima di essere aperto. Tutti i contenuti precedenti sono perduti
QIODevice.Text	0x0010	In lettura gli end-of-line vengono tradotti in ‘\n’. In scrittura gli end-of-line sono tradotti secondo il local encoding (es.’\r\n’ per Win32)
QIODevice.Unbuffered	0x0020	Ogni buffer nel dispositivo è bypassato
QIODevice.NewOnly	0x0040	Fallisce se il file da aprire, esiste già. Crea e apre il file, solo se non esiste
QIODevice.ExistingOnly	0x0080	Fallisce se il file da aprire, non esiste

il tipo di mode utilizzato si ottiene con il metodo openMode()

Di default, non avendolo ancora aperto, il file restituirà enum QIODevice.NotOpen:

>>> f.openMode().__int__()
0

Ora voglio aprirlo in modalità lettura\scrittura, passando quindi come mode flag QIODevice.ReadWrite:

>>> from PyQt5.QtCore import QIODevice
>>> f.open(QIODevice.ReadWrite)
True
>>> f.openMode().__int__()
3

3 è il valore unione di QIODevice.ReadOnly = 1 e QIODevice.WriteOnly = 2.
Il boolean True, certifica il buon esito dell’operazione di apertura.

Per modificare il mode mentre il file è aperto, si utilizza il metodo setOpenMode(mode):

>>> f.setOpenMode(QIODevice.ReadOnly)
>>> f.openMode().__int__()
1

Per chiudere un file aperto si utilizza il metodo close().

Nota:

Se apriamo un nuovo file, non ancora esistente, questi non verrà creato fino a chè non verrà chiamato il metodo open:

>>> newfile = QFile("C:/temp/newfile.txt")
>>> newfile.open(QIODevice.ReadWrite)
True

Per rinominare un file, si utilizza il metodo rename(newname).
In caso di buon esito dell’operazione, il metodo ritornerà True, altrimenti, qualora esistesse già un file con il nuovo nome da assegnare, ritornerà False:

>>> newfile.rename("C:/temp/test.txt")
False
>>> newfile.rename("C:/temp/test2.txt")
True

Per rimuovere un file, si utilizza il metodo remove():

>>> newfile.remove()
True

LETTURA E SCRITTURA

I dati contenuti in un file, solitamente sono letti e scritti utilizzando QDataStream e QTextStream. La prima classe fornisce una serializzazione di dati binari al QIODevice, la seconda invece fornisce un’interfaccia per la lettura e la scrittura di testo.

Possiamo anche usare i metodi di QFile, ereditati dalla classe QIODevice, che sono:

read(maxsize): legge un quantità di dati, pari all’argomento maxsize;

>>> f.close()
>>> f.open(QIODevice.ReadOnly)
True
>>> f.read(11)
b'Lorem ipsum'
>>> f.read(11)
b' dolor sit '

Ad ogni chiamata del metodo read(maxsize), la posizione all’interno del file avanza.
Per conoscere la posizione all’interno del file, si utilizza il metodo pos():

>>> f.pos()
22
>>> f.read(11)
b'amet, conse'
>>> f.pos()
33

Per spostarsi all’interno del file, si utilizza il metodo seek(position), dove position indica la posizione sulla quale ci sposteremo:

>>> f.seek(0)
True
>>> f.read(11)
b'Lorem ipsum'

Per sapere se abbiamo raggiunto la fine del file, si utilizza il metodo atEnd():

>>> f.atEnd()
False
>>> f.seek(f.size())
True
>>> f.read(11)
b''
>>> f.atEnd()
True

readLine: legge una riga alla volta;

>>> f.seek(0)
True
>>> while not f.atEnd():
...     print(f.readLine())
...     
b'Lorem ipsum dolor sit amet, consectetur adipisci elit, \r\n'
b'sed eiusmod tempor incidunt ut labore et dolore magna aliqua. \r\n'
b'Ut enim ad minim veniam, \r\n'
b'quis nostrum exercitationem ullam corporis suscipit laboriosam, \r\n'
b'nisi ut aliquid ex ea commodi consequatur. \r\n'
b'Quis aute iure reprehenderit in voluptate velit esse cillum dolore\r\n'
b' eu fugiat nulla pariatur. \r\n'
b'Excepteur sint obcaecat cupiditat non proident, \r\n'
b'sunt in culpa qui officia deserunt mollit anim id est laborum.'

readAll: ritorna un oggetto QByteArray che contiene tutto il contenuto del file, dalla posizione corrente fino alla fine;
Il contenuto dell’oggetto QByteArray si ottiene con il metodo data():

>>> f.readAll().data()
b''
>>> f.seek(0)
True
>>> data = f.readAll()
>>> data.size()
468
>>> data.data()
b'Lorem ipsum dolor sit amet, cons...

write:

Apriamo un nuovo file e scriviamo su di esso alcune stringhe.
Utilizziamo oggetti QByteArray per rappresentare i testi ed il metodo write(QByteArray) per passarli all’oggetto QFile.
Per scrivere fisicamente i dati sul file, chiamiamo il metodo flush():

>>> fw = QFile("C:/temp/write_test.txt")
>>> fw.open(QIODevice.ReadWrite | QIODevice.Text)
True
>>> data = QByteArray(b"first line\n")
>>> data.append(b"second line\n")
PyQt5.QtCore.QByteArray(b'first line\nsecond line\n')
>>> data.append(b"third line\n")
PyQt5.QtCore.QByteArray(b'first line\nsecond line\nthird line\n')
>>> fw.write(data)
34
>>> fw.flush()
True
>>> fw.close()

Nota:
Se non usassimo la union QIODevice.ReadWrite | QIODevice.Text in fase di apertura file, i ‘\n’ verrebbero eliminati.

SIZE

Come visto precedentemente, il size di un file si ottiene con il metodo size().

>>> fw.size()
37

POSITION

Come anticipato dagli esempi, la posizione all’interno del file si ottiene con il metodo pos().

>>> fw.open(QIODevice.ReadOnly)
True
>>> fw.read(5)
b'first'
>>> fw.pos()
5

FLUSH

Chiamando il metodo flush(), si scrivono i dati, presenti nel buffer, che aspettano di essere scritti sul dispositivo, nel nostro caso sul file.
Il metodo ritorna True o False a seconda del buon esito della scrittura.

COPY

Per copiare un file, si utizza il metodo copy(newname). Se newname è un nome che esiste già, il metodo ritornerà False, altrimenti, in caso di buona riuscita della copia, True:

>>> fw.copy("C:/temp/copy.txt")
True

LINK

E’ possibile creare link ad un file (collegamento su Win o symbolic-link su Unix) semplicemente con il metodo link(linkname):

>>> fw.link("C:/temp/link_to_write_test")
True

Torna all’indice degli appunti