Fluxos i accés a fitxers

Quan es treballa amb fitxers en programació, és necessari entendre què és un flux de fitxer i com funciona. Els fluxos de fitxer faciliten la comunicació entre el programa i el sistema d’emmagatzematge (el disc dur o altre dispositiu), i ajuden a controlar com la informació viatja entre l’ordinador i el fitxer. Veureu que, gràcies als fluxos, és possible llegir i escriure fitxers amb molta flexibilitat i control.

L’ús d’aquests fluxos i els seus mètodes us ajudarà a llegir i escriure fitxers de manera senzilla.

Això vol dir que, quan s’obre un fitxer, s’estableix un canal o flux de comunicació. Penseu en un flux com en un tub per on passa l’aigua: l’aigua pot anar en una direcció o en l’altra, però cal saber si s’està entrant o sortint de la canonada.

Hi ha dos tipus de fluxos principals:

• Flux de lectura: les dades flueixen del fitxer cap al programa, és a dir, el programa llegeix informació emmagatzemada en el fitxer.
• Flux d’escriptura: les dades flueixen del programa cap al fitxer, cosa que permet afegir o modificar informació dins del fitxer.

Quan es crea un flux, també es pot especificar si es vol accedir a tot el fitxer sencer o si només es vol llegir o escriure una part del seu contingut. Aquesta flexibilitat fa que es pugui gestionar la informació amb més eficiència.

Un altre aspecte important a considerar són els diferents tipus de fitxers amb els quals es pot treballar. Aquesta lliçó se centrarà principalment en els fitxers de text, però cal entendre breument la diferència entre els fitxers de text i els fitxers binaris.

Els fitxers de text són fitxers on la informació es guarda en format de caràcters llegibles (lletres, números, símbols) en un format com ara UTF-8. Quan s’obre un fitxer de text una aplicació s’encarrega de transformar els bytes a caràcters i es veuen frases, paraules o altres tipus de dades escrites.

Exemples de fitxers de text són els arxius .txt, .csv (valors separats per comes) o .json (format de dades estructurades).

Els fitxers binaris contenen dades emmagatzemades com a bits i bytes (uns i zeros), que no són directament llegibles per una persona. Aquests fitxers necessiten un programa o aplicació específica per ser interpretats correctament com a imatges i vídeos, o poden ser un magatzem de dades estructurades d’una manera concreta i que s’han de llegir amb unes instruccions precises.

Exemples de fitxers binaris són els fitxers d’imatge (.jpg, .png), fitxers de vídeo (.mp4) o fins i tot fitxers d’aplicació executables (.exe).

Tot i que qualsevol fitxer digital es compon de bits (zeros i uns), el flux i el tipus d’accés que s’utilitzen per treballar-hi han de ser diferents segons el tipus de fitxer: de text o binari.

• Fitxers de text: l’accés seqüencial és l’estàndard perquè s’espera que es llegeixin línies completes, i Python interpreta automàticament els caràcters especials (com els salts de línia), ja que es llegeixen o s’escriuen dades en format llegible per humans (caràcters, línies completes). Així, el flux avança per tot el fitxer de forma contínua. Es pot entendre gràficament com si el flux fos una canonada que goteja caràcter a caràcter. O potser seria millor indicar línia a línia, ja que els mètodes més utilitzats trossegen el fitxer original a partir del caràcter de salt de línia.

• Fitxers binaris: contenen dades en format de bytes, sovint és necessari l’accés directe per poder anar a posicions específiques. Per això, el flux pot ser manipulat per llegir o escriure en ubicacions concretes, sense necessitat de recórrer seqüencialment tot el fitxer. Aquesta flexibilitat fa el flux molt útil per fitxers grans i estructurats en blocs, com ara imatges o vídeos. En aquest cas ja no funciona la imatge gràfica de la canonada, ja que es pot accedir directament al caràcter que es vol. La imatge que més s’acosta és la de considerar un fitxer com una taula de dades, o caselles, i l’accés directe com la possibilitat de dirigir-se a una casella directament sense haver de passar per les anteriors.

Aquesta lliçó se centrarà en fitxers de text i en el tipus d’accés seqüencial.

Quan es treballa amb fitxers en Python, és fonamental saber com obrir-los i tancar-los correctament. Aquest procés estableix el flux de dades entre el programa i el fitxer, per la qual cosa es pot llegir o escriure en aquest amb seguretat.

fitxer = open("nom_fitxer.txt", "r")

Per accedir a un fitxer en Python, s’utilitza la funció integrada open(). Aquesta funció pren almenys dos arguments:

1. Nom del fitxer: la ruta o nom del fitxer que es vol obrir.
2. Mode d’obertura: defineix com s’accedirà al fitxer.

El mode d’obertura és una cadena que indica com s’obrirà el fitxer. En altres paraules, és el que decideix si l’accés es farà com si fos una canonada (mode seqüencial), o un taulell de caselles (mode directe). I si és per a rebre dades (mode lectura), o per escriure-les (mode escriptura).

Principals modes d’obertura de fitxers:

• “r”: mode de lectura (read). Només permet llegir el fitxer; si el fitxer no existeix, es genera un error.
• “w”: mode d’escriptura (write). Si el fitxer no existeix, es crea; si ja existeix, el contingut es sobreescriu.
• “a”: mode d’afegir (append). Permet escriure al final del fitxer sense sobreescriure el contingut existent.
• “b”: mode binari. Es pot combinar amb altres modes (“rb”, “wb”, etc.) per treballar amb fitxers en format de bytes en lloc de text.

Quan s’obre un fitxer amb open(), aquest retorna un objecte FILE que conté la informació del fitxer accedit i els recursos necessaris per manipular-lo.

Aquest objecte inclou les següents característiques:

• Ruta del fitxer: l’objecte FILE guarda la informació sobre la ubicació del fitxer, sigui en el sistema local o en una ubicació específica en una unitat.
• Mode d’obertura: en obrir el fitxer, se li indica un mode (“r”, “w”, “a”, etc.) que defineix com es treballarà amb el fitxer (lectura, escriptura, afegir…).
• Estat del fitxer: el fitxer es manté obert mentre s’estigui fent servir l’objecte FILE i es pot utilitzar per dur a terme diferents operacions. És important recordar que, mentre el fitxer estigui obert, ocuparà recursos del sistema.

Un cop s’ha acabat de treballar amb un flux de fitxer, és crucial tancar-lo amb el mètode close(). Això és important per diverses raons:

• Alliberació de recursos: cada fitxer obert consumeix recursos del sistema, com la memòria i espai de descriptors de fitxers. Si no es tanquen els fitxers, aquests recursos continuaran ocupats, la qual cosa pot afectar el rendiment i, en alguns casos, fins i tot esgotar els descriptors disponibles.
• Seguretat de les dades: quan es tanca un fitxer, el sistema s’assegura que totes les dades s’hagin escrit correctament al disc. Això és especialment important en fitxers oberts en mode d’escriptura, ja que tancar-los evita possibles pèrdues de dades en cas de talls inesperats de corrent o d’errors del programa.
• Evitar errors d’accés: mantenir un fitxer obert després d’haver acabat de treballar-hi pot causar problemes si es vol obrir el fitxer de nou, sigui en el mateix programa o en un altre procés.

El següent codi mostra com obrir un arxiu en mode lectura, i com tancar-ho. Aquest serà l’esquema bàsic de qualsevol programa que treballi amb arxius de text.

# Obrir el fitxer en mode de lectura
fitxer = open("nom_fitxer.txt", "r")
# llegir les dades
 
# Quan hem acabat de treballar amb el fitxer, es tanca
fitxer.close()
 
# Processar les dades

Un cop obert un fitxer en mode de lectura (“r”), Python ofereix diverses maneres d’obtenir-ne el contingut. Aquestes tècniques permeten treballar amb les dades d’acord amb les necessitats del programa, ja sigui llegint tot el contingut de cop, línia per línia o fins a un nombre determinat de caràcters.

Els fitxers de text estan organitzats en línies perquè són fàcils de processar tant per als programes com per als humans. En obrir un fitxer de text, Python sap reconèixer aquests salts de línia (\n) i considera cada línia com un bloc de dades que es pot llegir i processar de forma independent. Aquesta estructura ajuda a organitzar la informació de manera lògica i permet llegir dades en parts fàcilment manejables.

En els exemples següents s’utilitzarà el fitxer exemple.txt, que conté els caràcters següents:

hola
adeu Andreu

El fitxer conté 2 línies, acabades les dues en un salt de línia (després de la paraula Andreu s’ha afegit el caràcter ‘\n’).

Quan es parla d’un fitxer com un objecte iterable, significa que es pot llegir progressivament, element a element, sense haver de carregar tot el contingut de cop. En el cas d’un fitxer de text, aquests “elements” són les línies. Això vol dir que quan utilitzeu un bucle for sobre un fitxer, cada iteració del bucle obté una línia del fitxer, en ordre, fins que s’arriba al final.

La lectura de fitxers amb un bucle for és una de les maneres més naturals i eficients de treballar amb fitxers de text en Python. Aquesta forma de lectura té diversos avantatges:

• Eficiència en memòria: el bucle for llegeix cada línia una a una i no carrega tot el fitxer a la memòria, cosa que el fa ideal per fitxers grans.

• Simplicitat: la sintaxi és simple i fàcil de llegir, fent que el codi sigui més comprensible.

El següent codi és un exemple de lectura d’un fitxer amb el bucle for:

fitxer = open("exemple.txt", "r")
for linia in fitxer:
    print(linia.strip())  # .strip() elimina el salt de línia al final
fitxer.close()

Aquest és el resultat de l’execució del programa (si s’executa en un directori en el qual hi ha el programa i el fitxer exemple.txt)

$ python3 metode_read.py 
hola
adeu Andreu

L’objecte FILE de Python proporciona diferents mètodes per llegir el contingut d’un fitxer, segons el volum de dades o la manera en què es vol gestionar la informació.

Mètode read(): llegir tot el contingut

Aquest mètode llegeix tot el contingut del fitxer de cop i retorna una cadena amb les dades.

En el codi següent es crea un flux de fitxer que llegeix tot el fitxer de cop i el desa a la variable contingut:

fitxer = open("exemple.txt", "r")
contingut = fitxer.read()
fitxer.close()
 
print(contingut)

Aquest mètode permet llegir tot el fitxer de cop. El que en principi sembla un avantatge per la seva simplicitat no ho és: els fitxers de text poden arribar a ser molt grans i col·lapsar la memòria.

El mètode readline(): llegir una línia

Si només es necessita una línia (o no cal llegir el fitxer sencer), readline() llegeix la següent línia del fitxer.

fitxer = open("exemple.txt", "r")
linia = fitxer.readline()
fitxer.close()
 
print(linia)
print(linia.strip())

El resultat de l’execució (si es troben el fitxer i el programa en el directori actiu), és el següent:

$ python3 metode_readline.py 
hola
 
hola

Aquest exemple també mostra la feina del mètode strip(): si no es neteja la línia, en combinar-la amb la funció print() apareixen dos salts de línia, el que ja duia la mateixa línia i el que afegeix print(). Per això print(linia) imprimeix després de la primera línia (“hola”) un salt de línia extra.

El mètode readlines(): llegir totes les línies com a llista

El mètode readlines() llegeix totes les línies i les retorna com una llista de cadenes, on cada element és una línia del fitxer.

Fixeu-vos en el codi següent

fitxer = open("exemple.txt", "r")
linies = fitxer.readlines()
fitxer.close()
 
print(linies)

I en el resultat de l’execució

$ python3 metode_readline.py 
['hola\n', 'adeu Andreu\n']

Aquest mètode, com en el cas de readline(), incorpora els salts de línia a la cadena.

S’ha d’utilitzar amb les mateixes restriccions que read(), donat que es carrega tota la informació del fitxer en memòria de cop.

Reviseu els exemples anteriors i adoneu-vos que el flux de fitxer es tanca sempre, amb el mètode close(), abans de processar les dades, ni que l’únic procés sigui mostrar-les per la sortida estàndard.

Quan es treballa amb fitxers, convé mantenir el fitxer obert només el temps necessari per accedir a les dades i, a continuació, tancar-lo immediatament. És una pràctica recomanada llegir les dades que es necessiten i, un cop obtingudes, fer el processament de la informació amb el fitxer ja tancat. Això té diversos avantatges:

• Reducció de l’ús de recursos: mantenir un fitxer obert ocupa recursos del sistema, com memòria i descriptors de fitxers. En tancar-lo ràpidament, alliberem aquests recursos i reduïm la càrrega del sistema, especialment si es treballa amb molts fitxers o en aplicacions grans.
• Millor seguretat i consistència de dades: quan un fitxer es tanca, el sistema s’assegura que les dades es guarden correctament. Si el fitxer es manté obert durant un llarg període, hi ha un major risc de pèrdua de dades en cas d’errors del programa o talls d’alimentació.
• Evitar bloquejos o errors d’accés: altres programes o processos podrien necessitar accedir al mateix fitxer. Si es manté obert innecessàriament, podria bloquejar altres processos o provocar errors d’accés, especialment en entorns compartits.

Aquest enfocament permet que el codi sigui més eficient, segur i fàcil de gestionar.

Quan es treballa amb escriptura de fitxers en Python, es pot obrir un fitxer en diferents maneres (modes), depenent de si es vol escriure noves dades o afegir-les a un fitxer existent.

Aquest mode crea un fitxer nou si el fitxer a obrir no existeix. Si ja existeix sobreescriu el fitxer existent. Cada vegada que s’obre el fitxer en mode “w”, es buida el seu contingut anterior.

En l’exemple següent s’utilitzarà el fitxer exemple1.txt, que conté els caràcters següents:

Andreu

El fitxer conté 1 línia, acabada en un salt de línia (després de la paraula Andreu s’ha afegit el caràcter ‘\n’).

Fixeu-vos en el codi següent del programa metode_write.py que escriu un fitxer exemple1.txt.

fitxer = open("exemple1.txt", "w")
fitxer.write('Se sobreescriu el fitxer\n')
fitxer.close()

Aquest és el resultat de la seva execució.

$ python3 metode_write.py 
videoioc@debian-xtec:~/Documents/programacio/UF3$ cat exemple1.txt 
Se sobreescriu el fitxer

En aquest cas, podeu comprovar com “Andreu” ha desaparegut del fitxer exemple1.txt.

Aquest mode també obre el fitxer per escriptura, però, en aquest cas, conserva el contingut existent i hi afegeix noves dades al final. És útil quan es volen anar afegint registres o línies sense perdre el que hi havia al fitxer

fitxer = open("exemple.txt", "a")
fitxer.write('adeu\n')
fitxer.close()

I el resultat de l’execució amb el fitxer exemple original

$ python3 metode_write.py 
$ cat exemple.txt 
hola
adeu Andreu
adeu

Els fitxers de text solen estar estructurats en línies, però la decisió de l’estructura del fitxer resultant és del programador. A continuació, podeu veure en dos exemples com usar el mode “w” d’escriptura i com usar el mode “a” d’afegir. El següent codi mostra com es crea un fitxer nou (o es sobreescriu sa ja existia):

dades = ["Línia 1", "Línia 2", "Línia 3"]
 
fitxer = open("sobreescrit.txt", "w")
for linia in dades:
    fitxer.write(linia + "\n")  # Afegim \n per separar cada línia
fitxer.close()

Amb el següent resultat d’execució:

$ python3 exemple1.py 
$ cat sobreescrit.txt 
Línia 1
Línia 2
Línia 3

El següent codi mostra com es fa per afegir dades a un fitxer ja existent:

noves_dades = ["Línia 4", "Línia 5"]
 
fitxer = open("sobreescrit.txt", "a")
for linia in noves_dades:
    fitxer.write(linia + "\n")
fitxer.close()

Amb el següent resultat d’execució, entenent que el fitxer sobreescrit és el resultant de l’execució anterior:

$ python3 exemple2.py 
$ cat sobreescrit.txt 
Línia 1
Línia 2
Línia 3
Línia 4
Línia 5

Atenció, el mode d’escriptura “a”, permet afegir el text que es desitgi al final d’un fitxer existent. En cas que el fitxer no existeixi, se’n crea un de nou amb la informació aportada.

Quan es treballa amb fitxers, poden aparèixer diversos errors que, si no es gestionen adequadament, poden provocar que el programa falli de forma inesperada. En Python, la lectura i escriptura de fitxers es pot gestionar amb l’estructura try-except-finally per evitar aquests problemes i assegurar que el programa continua funcionant, fins i tot si es produeix un error.

Els errors comuns en la lectura i escriptura de fitxers són els següents:

• Fitxer inexistent: si s’intenta obrir un fitxer per llegir (“r”) que no existeix, Python generarà un error del tipus FileNotFoundError.
• Permisos insuficients: si el programa intenta escriure en un fitxer sense permisos suficients o en un directori protegit, es produirà un error de tipus PermissionError.
• Fitxer obert en el mode equivocat: intentar llegir en un fitxer obert en mode escriptura (“w”) o escriure en un fitxer obert en mode lectura (“r”) genera un error UnsupportedOperation.
• Fitxer ja tancat: si es vol llegir o escriure en un fitxer després de tancar-lo, Python mostrarà un error ValueError.
• Errors diversos d’entrada/sortida: l’operació de trasllat de dades entre un programa i un fitxer sempre pot provocar errors diversos de dades (que el disc dur estigui malmès, que es retiri el llapis de memòria que conté el fitxer…). Tot aquest tipus d’errors, i els anteriors es troben compresos en l’error genèric IOError.

Les clàusules indiquen el següent:

• try: conté el codi que pot provocar un error. Si es produeix una excepció en aquest bloc, es deixa d’executar i es passa al bloc except.
• except: aquest bloc s’executa només si es produeix una excepció en el bloc try. Permet gestionar errors específics (com FileNotFoundError) o genèrics (si no s’especifica el tipus es recull qualsevol Exception que s’hagi produït.
• finally: aquest bloc s’executa sempre, tant si es produeix una excepció com si no. S’utilitza per assegurar que es compleixin accions crítiques, com tancar un fitxer o alliberar recursos.

Gestió de FileNotFoundError

El següent codi mostra com gestionar un error de tipus FileNotFoundError.

try:
    fitxer = open("inexistent.txt", "r")
    contingut = fitxer.read()
    fitxer.close()
except FileNotFoundError:
    print("Error: El fitxer no existeix.")

Aquí, si el fitxer no es troba, Python executa el bloc except, mostrant un missatge d’error en lloc de fallar.

Si s’executa aquest programa en un directori en què no hi hagi cap fitxer amb el nom inexistent.txt, s’aconsegueix que el programa acabi de manera neta mostrant un missatge d’error.

$ python3 exemple3.py 
Error: El fitxer no existeix.

Consideracions amb l’ús del try-except amb els fitxers per a aquest curs:

• Dins del try s’incorporaran les accions perilloses quan es treballa en fitxers, com són l’obertura i la lectura o escriptura de dades.
• Serà necessari l’ús de dos try niuats, el primer per a comprovar l’existència del fitxer i el segon per a recollir qualsevol error d’entrada/sortida.
• En l’exterior es tractarà el cas del FileNotFoundError. Si el fitxer no existeix es recollirà l’error i s’acabarà el programa.
• En l’interior es tractaran tots els altres problemes de lectura. Com que el fitxer estarà obert, caldrà tancar-lo sempre i, per això, serà necessari l’ús de la clàusula finally, per assegurar-ne el tancament.
• Els errors d’entrada i sortida es consideren fatals per al programa, ja que impedeixen la seva execució. És per això que es tractarà el try-except com a un control d’errors i es permet l’ús de la funció exit(). El control d’errors no ha de seguir els preceptes de la programació estructurada.
• El processament de les dades es farà, sempre que sigui possible, després d’haver tancat el fitxer.

Gestió de IOErrors en els nostres programes

El següent codi mostra com realitzar el control d’errors d’entrada i sortida tenint en compte errors de tipus IOError. És un model pels programes en els quals feu ús dels fitxers.

try:
	#obertura
    fitxer = open("exemple.txt", "r")
 
    try:
		#lectura
        contingut = fitxer.read()
    except IOError as e:
        print(f"S'ha produït un error inesperat: {e}")
        exit(1)
 
    finally:
        fitxer.close()
 
except FileNotFoundError:
    print("Error: No s'ha trobat el fitxer.")
    exit(1)
 
#processament de les dades
print(contingut)

En Python, stdin (entrada estàndard), stdout (sortida estàndard) i stderr (sortida d’errors estàndard) es gestionen com a fluxos de fitxer. Això vol dir que es poden llegir dades des de stdin o escriure-les a stdout i stderr de manera similar a com es treballaria amb un fitxer de text.

stdin representa el flux d’entrada estàndard, que és on el programa rep informació, generalment des del teclat o d’una altra font d’entrada. La funció input() utilitza stdin, però es pot accedir a aquest flux directament amb sys.stdin per a operacions de lectura més personalitzades, com llegir múltiples línies o processar dades contínuament.

Si executeu el següent fitxer, podeu anar entrant dades fins que introduïu el EOF (Ctrl+d).

import sys
 
for linia in sys.stdin:
    print(f"línia: {linia.strip()}")

En la següent execució s’ha introduït les línies hola i adeu.

$ python3 exemple4.py 
hola
línia: hola
adeu
línia: adeu

stdout és el flux de sortida estàndard, que envia informació a la pantalla de forma predeterminada. La funció print() envia les dades a stdout i afegeix un salt de línia al final, però també es pot accedir a aquest flux directament amb sys.stdout, cosa que permet un control més fi sobre l’escriptura, com ara afegir o ometre el salt de línia automàtic.

En el següent exemple s’utilitza sys.stdout.write() per escriure directament al flux de sortida, afegint un salt de línia manualment. Això és especialment útil quan es requereix una sortida personalitzada.

import sys
 
missatge = "Aquest missatge es mostrarà per stdout."
sys.stdout.write(missatge + "\n")

stderr és un flux de sortida reservat per als missatges d’error. En lloc d’imprimir errors o advertències a stdout, es poden enviar a stderr per a distingir-los de la sortida normal. Això facilita la separació de la informació general dels errors, especialment en aplicacions complexes o en sistemes que processen la sortida de manera automàtica.

Tots tres fluxos (sys.stdin, sys.stdout i sys.stderr) funcionen com a fitxers temporals que estan sempre oberts per a l’entrada i la sortida. Això permet llegir o escriure dades contínuament, com si es tractés d’un fitxer de text, i resulta especialment útil en aplicacions que processen dades en temps real o en entorns que utilitzen pipes (|) per passar dades entre programes.

Un dels conceptes clau en programació és el de modularitat, és a dir, dividir el codi en petites parts o mòduls (com ara funcions) que es poden entendre, provar i mantenir de forma independent. Aquest enfocament facilita la programació i fa que el codi sigui més net i organitzat.

En programació modular, se segueix el principi de responsabilitat única. Aquest principi estableix que cada funció o mòdul hauria de tenir una sola responsabilitat o objectiu. Per exemple:

• Una funció que només llegeixi un fitxer.
• Una funció separada que només mostri les dades.

Aquest principi ajuda a construir codi reutilitzable i fàcil de modificar, perquè qualsevol canvi en una funció no afectarà altres parts del programa.

Fins ara, s’ha explicat que la gestió de les dades d’entrada i sortida es fa des del programa principal. En començar a programar se us va indicar que la lectura de dades (sigui amb la funció input() per l’entrada estàndard, o de sys.argv si s’entra per argument des de la línia d’ordres) es fes també des del programa principal.

Això no sempre ha de ser així. Es poden definir funcions específiques per gestionar la sortida de les dades. En serien exemples la funció histograma() del mòdul diccionaris i la funció factura() del mòdul supermercat. Són funcions que no retornen res, i la seva única missió és mostrar les dades d’una manera determinada.

Amb la incorporació de l’ús de fitxers en els vostres programes, caldrà revisar els conceptes adquirits fins ara, i creareu funcions per a gestionar els fluxos dels fitxers.

La recomanació és fer, sempre que sigui possible:

• El programa principal que gestiona el flux d’inici a final (obertura i tancament del fitxer) i delega la lectura a una funció.
• La funció específica per llegir i carregar les dades, que només necessiti el flux obert (el fitxer) com a argument, sense preocupar-se d’obrir-lo o tancar-lo.
• El mateix plantejament s’utilitzarà per a l’escriptura de fitxers.
• La gestió dels errors d’entrada i sortida la farà el programa principal, amb l’ús dels try-except.

Això permetrà reutilitzar la funció de lectura amb qualsevol fitxer obert, fent que el codi sigui més versàtil i fàcil de mantenir.

Sempre que sigui possible (ja que en alguns programes cal mantenir oberts al mateix temps els fitxers de lectura i escriptura, i en altres s’han de processar les dades a mesura que es van llegint), cal seguir l’esquema següent:

1. Obertura de fitxer de lectura
2. Lectura de dades (passant el flux a una funció si s’escau)
3. Tancament del fitxer de lectura
4. Processament les dades
5. Obertura del fitxer d’escriptura
6. Escriptura de dades (passant el flux a una funció si s’escau)
7. Tancament del fitxer d’escriptura

L’objectiu serà incorporar al mòdul de funcions relacionades amb la gestió dels usuaris del sistema, la funció necessària per a fer un programa que llegeixi els usuaris del sistema.

Aquest és el mòdul en la seva fase inicial:

'''
Mòdul de funcions amb utilitats per treballar amb /etc/passwd.
L'estructura de dades és la seguent:
diccionari_general = {login: {diccionari d'usuari}}
diccionari d'usuari = {'UID': '0', 'GUID': '0', 'shell': '/bin/bash'}
 
exemple = {'root': {'UID': '0', 'GUID': '0', 'shell': '/bin/bash'}}
'''
 
# Funcions per crear el diccionari
def diccionari_usuari(camps):
	'''
	Funció que crea un diccionari d'usuari a partir dels camps 
	d'una línia del fitxer /etc/passwd
	Entrada: llista de str
	Sortida: diccionari
	'''
	dic = {}
	dic['UID'] = camps[2]
	dic['GUID'] = camps[3]
	dic['shell'] = camps[6]
	return dic
 
def afegir_usuari(linia, dic_total):
	'''
	Funció que afegeix un usuari al diccionari d'usuaris a partir 
	d'una línia del fitxer /etc/passwd
	'''
	camps = linia.strip().split(':')
	dic_total[camps[0]]  = diccionari_usuari(camps)
	return None
 
# Funcions per fer llistats
def usuari_to_str(login, d_usuari):
	'''
	Funció que converteix un diccionari d'usuari a cadena per a 
	escriure el llistat:
	Entrada: login, diccionari d'usuari
	Sortida: str
	'''
	return f"login: {login}, UID: {d_usuari['UID']}, GUID: {d_usuari['GUID']}"
 
def llistat(dic_general, taula):
	'''
	Funció per a imprimir la factura, segons l'ordre de la taula
	Entrada: diccionari d'articles, llista (taula de la compra)
	Sortida: None
	'''
 
	for clau, valor in taula:
		print(usuari_to_str(clau, dic_general[clau]))
	return None
 
if __name__ == "__main__":
	# test-drivers	
	if False:
		print(diccionari_usuari(['root', 'x', '0', '0', 'root', 
		'/root', '/bin/bash']))
	if False:
		dic = {}
		afegir_usuari('root:x:0:0:root:/root:/bin/bash', dic)
		afegir_usuari('bin:x:1:1:bin:/bin:/sbin/nologin', dic)
		print(dic)
	if True:
		print(usuari_to_str('root', {'UID': '0', 'GUID': '0', 'shell': 
			'/bin/bash'}))
		print()
	if True:
		dic = {}
		afegir_usuari('root:x:0:0:root:/root:/bin/bash', dic)
		afegir_usuari('bin:x:1:1:bin:/bin:/sbin/nologin', dic)
		taula = sorted(dic.items())
		llistat(dic, taula)

Lectura de les dades del fitxer

El primer pas serà gestionar la lectura de les dades del fitxer per a omplir el diccionari d’usuaris. L’objectiu del primer programa serà llegir les dades del fitxer i mostrar el diccionari dels usuaris.

El refinament del programa és el següent:

#obertura del fitxer
#lectura de dades
#tancament del fitxer
#mostrar el diccionari

Només caldrà definir la funció que creï el diccionari a partir del flux del fitxer obert en el programa.

El docstring de la nova funció serà el següent:

def crear_diccionari(flux_fitxer):
	'''
	Funció que llegeix i estructura les dades en un diccionari d'usuaris
	Entrada: fluxe de fitxer en mode lectura
	Sortida: diccionari amb les dades dels usuaris.
	'''

El codi d’aquesta funció serà senzill, ja que es limitarà a recórrer el flux línia a línia i a cridar a la funció afegir_usuari() que ja havíeu definit.

def crear_diccionari(flux_fitxer):
	'''
	Funció que llegeix i estructura les dades en un diccionari d'usuaris
	Entrada: fluxe de fitxer en mode lectura
	Sortida: diccionari amb les dades dels usuaris.
	'''
	dic = {}
	#lectura de dades
	for linia in flux_fitxer:
		linia = linia.strip() #per netejar el intro
		afegir_usuari(linia, dic)
	return dic

Ja només falta muntar el programa principal, que serà el següent:

import passwd
 
USUARIS = 'etc_passwd.txt'  #/etc/passwd per accedir al sistema
 
#obertura del fitxer de lectura
fluxe = open(USUARIS, 'r')
 
#lectura de dades
dic = passwd.crear_diccionari(fluxe)
 
#tancament del fitxer
fluxe.close()
 
#processament de dades
print(dic)

Per veure com funciona, podeu utilitzar el fitxer etc_passwd.txt següent:

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
joan:x:1002:1000:joan,,,:/home/joan:/bin/bash
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:50:games:/usr/games:/usr/sbin/nologin

I aquest serà el resultat d’execució:

$ python3 llistats_passwd.py 
{'root': {'UID': '0', 'GUID': '0', 'shell': '/bin/bash'}, 'daemon': {'UID': '1', 'GUID': '1', 'shell': '/usr/sbin/nologin'}, 'bin': {'UID': '2', 'GUID': '2', 'shell': '/usr/sbin/nologin'}, 'sys': {'UID': '3', 'GUID': '3', 'shell': '/usr/sbin/nologin'}, 'joan': {'UID': '1002', 'GUID': '1000', 'shell': '/bin/bash'}, 'sync': {'UID': '4', 'GUID': '65534', 'shell': '/bin/sync'}, 'games': {'UID': '5', 'GUID': '50', 'shell': '/usr/sbin/nologin'}}

Control d’errors

Per acabar, cal afegir els try-except que gestionin els possibles errors que es poden ocasionar amb l’entrada de les dades.

Com s’ha dit en el capítol del control d’errors, és necessari escriure dues clàusules try niuades, l’exterior per a gestionar els errors ocasionats per la inexistència del fitxer, i la interior per a tots els altres, afegint també la clàusula finally per assegurar-vos del tancament del fitxer.

Seguint la recepta, el programa resultant, amb el control d’errors serà aquest

import passwd
 
USUARIS = 'etc_passwd.txt'  #/etc/passwd per accedir al sistema
 
try:
	#obertura del fitxer de lectura
	fluxe = open(USUARIS, 'r')
 
	try:
		#lectura de dades
		dic = passwd.crear_diccionari(fluxe)
	except IOError as e:
		print(f"S'ha produït un error inesperat: {e}")
		exit(1)
	finally:
		fluxe.close()
 
except FileNotFoundError:
	print("Error: No s'ha trobat el fitxer.")
	exit(1)
 
#processament de dades
print(dic)

Que s’ha d’executar amb el mòdul passwd complet:

'''
Mòdul de funcions amb utilitats per treballar amb /etc/passwd.
L'estructura de dades és la seguent:
diccionari_general = {login: {diccionari d'usuari}}
diccionari d'usuari = {'UID': '0', 'GUID': '0', 'shell': '/bin/bash'}
 
exemple = {'root': {'UID': '0', 'GUID': '0', 'shell': '/bin/bash'}}
'''
 
# Funcions per crear el diccionari
def diccionari_usuari(camps):
	'''
	Funció que crea un diccionari d'usuari a partir dels camps 
	d'una línia del fitxer /etc/passwd
	Entrada: llista de str
	Sortida: diccionari
	'''
	dic = {}
	dic['UID'] = camps[2]
	dic['GUID'] = camps[3]
	dic['shell'] = camps[6]
	return dic
 
def afegir_usuari(linia, dic_total):
	'''
	Funció que afegeix un usuari al diccionari d'usuaris a partir 
	d'una línia del fitxer /etc/passwd
	'''
	camps = linia.strip().split(':')
	dic_total[camps[0]]  = diccionari_usuari(camps)
	return None
 
# Funcions per fer llistats
def usuari_to_str(login, d_usuari):
	'''
	Funció que converteix un diccionari d'usuari a cadena per a 
	escriure el llistat:
	Entrada: login, diccionari d'usuari
	Sortida: str
	'''
	return f"login: {login}, UID: {d_usuari['UID']}, GUID: {d_usuari['GUID']}"
 
def llistat(dic_general, taula):
	'''
	Funció per a imprimir la factura, segons l'ordre de la taula
	Entrada: diccionari d'articles, llista (taula de la compra)
	Sortida: None
	'''
 
	for clau, valor in taula:
		print(usuari_to_str(clau, dic_general[clau]))
	return None
 
# lectura del fitxer
def crear_diccionari(flux_fitxer):
	'''
	Funció que llegeix i estructura les dades en un diccionari d'usuaris
	Entrada: fluxe de fitxer en mode lectura
	Sortida: diccionari amb les dades dels usuaris.
	'''
	dic = {}
	#lectura de dades
	for linia in flux_fitxer:
		linia = linia.strip() #per netejar el intro
		afegir_usuari(linia, dic)
	return dic
 
 
if __name__ == "__main__":
	# test-drivers	
	if False:
		print(diccionari_usuari(['root', 'x', '0', '0', 'root', 
		'/root', '/bin/bash']))
	if False:
		dic = {}
		afegir_usuari('root:x:0:0:root:/root:/bin/bash', dic)
		afegir_usuari('bin:x:1:1:bin:/bin:/sbin/nologin', dic)
		print(dic)
	if True:
		print(usuari_to_str('root', {'UID': '0', 'GUID': '0', 'shell': 
			'/bin/bash'}))
		print()
	if True:
		dic = {}
		afegir_usuari('root:x:0:0:root:/root:/bin/bash', dic)
		afegir_usuari('bin:x:1:1:bin:/bin:/sbin/nologin', dic)
		taula = sorted(dic.items())
		llistat(dic, taula)