Friday, 20 October 2017
Administración de archivos

Administración de ARCHIVOS

Para trabajar con archivos, al igual que con los libros, primero se deben abrir. Cuando se abre un archivo se crea un objeto de tipo archivo. La función utilizada para abrir un archivo es "open", la cual toma dos argumentos: el primero se refiere al nombre del archivo y el segundo al modo en que se quiere abrir. La siguiente tabla muestra los posibles valores del modo para abrir archivos.

Modo lectura "b": Abre el archivo en modo lectura. El archivo tiene que existir previamente, en caso contrario se lanzará una excepción de tipo IOError.

Modo escritura "w": Abre el archivo en modo escritura. Si el archivo no existe se crea. Si existe, sobreescribe el contenido.

Modo de agregado "a" : Abre el archivo en modo escritura. Se diferencia del modo 'w' en que en este caso no se sobreescribe el contenido del archivo, sino que se comienza a escribir al final del archivo.

Modo binario (en conjunto con otro modo) "b"

Modo de lectura/escritura (conj otro modo) "+": permite lectura y escritura simultáneas.

El modo “w” indica que se quiere escribir en él, el modo “r” indica que se quiere leer de él. En el caso de que se quiera leer un archivo binario, tal como un clip de sonido o una imagen, se debe agregar una “b” al modo de lectura, en este caso sería “rb”.

Abrir archivos
archivo = open("nombre.txt", "w") | Si el archivo no existe lo crea, sobreescribe el archivo en caso que exista.



CERRAR ARCHIVOS

El cerrar un archivo es la operación que le indica al sistema que se ha terminado de trabajar con el archivo, y que queda disponible para un uso posterior. Ejemplo
out_file.close()


LEER ARCHIVOS

Para la lectura de archivos se utilizan los métodos read, readline y realines.

El método "read" permite leer datos del archivo. Sin argumentos, este método lee el contenido entero del archivo. El método "read" puede tomar un argumento que indica cuántos caracteres se deben leer. Cuando se llega al final del archivo, el método "read" retorna una hilera vacía.
El método readline: sirve para leer las líneas del fichero una por una. Es decir, cada vez que se llama a este método, se devuelve el contenido del archivo desde el puntero hasta que se encuentra un carácter de nueva línea, incluyendo este carácter.
Readlines, funciona leyendo todas las líneas del archivo y devolviendo una lista con las líneas leídas.
***********************************
archivo = open("nombres.txt", "r") | Leer un archivo

*********************************************
def load_numbers(numbers, filename):

 

in_file = open(filename, "r")
while True:

in_line = in_file.readline()
if not in_line:

break

in_line = in_line[:-1]
name, number = in_line.split(",")
numbers[name] = number

in_file.close()

 

*********************************************

 


GRABAR ARCHIVOS
Para la escritura de archivos se utilizan los método write y writelines

El primero funciona escribiendo en el archivo una cadena de texto que toma como parámetro,
el segundo toma como parámetro una lista de cadenas de texto indicando las líneas que queremos escribir en el fichero.

out_file.write("This Text is going to out file\nLook at it and see!")

Añadir a archivos
archivo = open("nombre.txt", "a") | significa si el archivo no existe lo crea y añade el contenido de las lineas en el archivo, pero si este ya existe se va al final del archivo y lo añade.

Resumen

output = open('/tmp/spam', 'w') Create output file ('w' means write)
input = open('data', 'r') Create input file ('r' means read)
S = input.read() Read entire file into a single string
S = input.read(N) Read N bytes (1 or more)
S = input.readline() Read next line (through end-line marker)
L = input.readlines() Read entire file into list of line strings
output.write(S) Write string S onto file
output.writelines(L) Write all lines strings in list L onto file
output.close() Manual close (or it's done for you when collecte
d)
GRABANDO VARIABLES
El argumento de “write” debe ser un string. En el siguiente ejemplo se desea grabar un entero, por lo que el entero se debe primero convertir a string para luego grabarlo. Como alternativa se puede usar el operador de formato de string “%”.

EL MÓDULO “PICKLE”

El módulo “pickle” contiene los comandos necesarios para grabar y leer variables de varios tipos, y no solo strings. Para usarlo se debe importar y luego abrir el archivo en la forma usual.

Ejercicios:
1) La siguiente función copia el archivo, leyendo y escribiendo hasta 50 caracteres a la vez. El primer parámetro es el nombre del archivo original, mientras que el segundo es el nombre del nuevo archivo:
def copiarArchivo(archivoAntiguo, archivoNuevo):

f1 = open(archivoAntiguo, "r")
f2 = open(archivoNuevo, "w")

while 1:

texto = f1.read(50)

 

if texto == "":

break 

 
 

f2.write(texto)

f1.close()

 

 

f2.close()
return

 

 

La sentencia break es nueva. Al ejecutarla se rompe el bucle y el flujo de ejecución va hacia la primera sentencia después del bucle.
En este ejemplo, el bucle while es infinito porque el valor 1 es siempre verdadero. La única manera de salir del bucle es mediante la ejecución de break, lo que tiene lugar cuando texto es una cadena vac�a; y suele suceder cuando llegamos al final del archivo.

2) Creando un archivo de texto con tres líneas de texto separadas por saltos de línea:
>>> f = open("test.dat","w")
>>> f.write("linea uno\nlinea dos\nlinea tres\n")
>>> f.close()

3) Lectura de una línea de un archivo utilizando "readline" ( lee todos los caracteres hasta el próximo carácter de salto de línea, esté incluido)
>>> f = open("test.dat","r")
>>> print( f.readline() )
linea uno


4) Generar una lista que contenga las líneas del archivo:
>>> readlines devuelve todas las línneas restantes como una lista de cadenas:
>>> print( f.readlines() )
['linea dos\012', 'linea tres\012']


En este caso, el resultado está en el formato de lista, lo que significa que las cadenas aparecen entre comillas y el carácter de línea nueva aparece como una secuencia de escape <br>012.

5) Abrir un archivo en u directorio específico:
>>> f = open("/usr/compartir/dicc/texto","r")
>>> print( f.readline() )

Aarhus

6) Almacenando una estructura de datos:
>>> import pickle
>>> f = open("test.pck","w")
>>> pickle.dump(12.3, f)
>>> pickle.dump([1,2,3], f)
>>> f.close()


7) Abrir archivo con variables:
>>> f = open("test.pck","r")
>>> x = pickle.load(f)
>>> x
12.3
>>> type(x)
<type 'float'>
>>> y = pickle.load(f)
>>> y
[1, 2, 3]
>>> type(y)
<type 'list'>


8) Ahora vamos a escribir un programa que lea el archivo y nos muestre su contenido (como los comandos 'cat' en Unix o 'type' en DOS:
# Primero abrimos el archivo en modo lectura (r)
inp = open("menu.txt","r")
# leemos el archivo, colocamos el contenido en una lista
# e imprimimos cada item
for linea in inp.readlines():

 

print( linea)
# Ahora lo cerramos

inp.close()

9) Como ejemplo supongamos que tenemos un archivo donde guardamos mensajes de error, y por supuesto no queremos borrar los mensajes que tenemos sino ir acumulándolos de manera secuencial:

 

def logError(msg):

 

err = open("Errores.log","a")
err.write(msg)

 

err.close()

 

10) Contar el número de palabras en un archivo de texto:
import string
def numpalabras(s):
 

lista = string.split(s) # necesitamos prefijar a split() con el módulo string
return len(lista) # devuelve el número de elementos en lista

inp = open("menu.txt","r")
total = 0 # inicializamos total en cero, también creamos la variable

for linea in inp.readlines():

total = total + numpalabras(linea) # acumula el total de cada línea 
print ("El archivo tiene %d palabras" % total)

inp.close()

{backbutton}