Python / Abriendo archivos

Bienvenidos sean a este post, hoy veremos el primer post de como trabajar con archivos.

A partir de aqui comenzaremos una serie de post donde no solo trabajaremos con archivos sino tambien con directorios, veremos todas las acciones basicas posibles y un poco mas alla, comencemos con el primer tema.

Abriendo archivos

Python para abrir archivos lo hace de una forma muy facil e intuitiva porque lo hace a traves de open, vamos a hacer un ejemplo:

>>> fh = open("estatico.py", "rt")

Primero abriremos un archivo de los que creamos anteriormente, asumiendo que estamos en la carpeta donde fue creada, para ello usamos open y pasamos el nombre del archivo, seguido de unos parametros:

• r es para indicar que es para leer
• t es para indicar que es de texto

Es decir que le indicamos que el archivo es de tipo texto para accederlo de esta manera y que a este lo abriremos para leerlo, todo esto lo almacenaremos en un objeto llamado fh, con esto tenemos el objeto iterable pasemos a recuperar la informacion:

>>> for linea in fh.readlines():
...     print(linea.strip())
...

Para esto usaremos a linea para almacenar la informacion, le pasamos el objeto y la iteracion la hara el metodo readlines, dentro de este bloque mostraremos el contenido de linea pero con el metodo strip para que elimine los espacios en blanco de las lineas, veamos su salida:

class UtilCadena:

@classmethod
def es_palindromo(cls, t, case_nosensitivo=True):
t = cls._limpiar_texto(t)
if case_nosensitivo:
t = t.lower()
return cls._es_palindromo(t)

@staticmethod
def _limpiar_texto(t):
return ''.join(c for c in t if c.isalnum())

@staticmethod
def _es_palindromo(t):
for c in range(len(t) // 2):
if t[c] != t[-c -1]:
return False
return True

@staticmethod
def get_palabras_unicas(sentencia):
return set(sentencia.split())


>>>

Como pueden ver nos trajo todo el contenido y elimino todos los tabuladores que dan la estructura a nuestro archivo, para finalizar debemos liberar el archivo almacenado en fh mediante el siguiente metodo:

>>> fh.close()

Con nuestro archivo liberado no solamente lo liberamos de memoria sino que tambien lo liberamos de nuestro disco, como se daran cuenta esto es lo mas critico porque sino lo liberamos puede evitar que otra parte del sistema o codigo pueda accederlo y generar un error pero hay una forma de evitar que nos olvidemos de cerrarlo y es gracias a try/finally pero para ello vamos a crear un nuevo archivo de texto con alguna informacion, les dejo un ejemplo:

prueba.txt

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Una vez creado el archivo procederemos a crear otro archivo llamado abrir.py al cual le agregaremos el siguiente codigo:

abrir.py

try:
	fh = open('prueba.txt')
	for linea in fh.readlines():
		print(linea.strip())

finally:
	fh.close()

En este caso utilizamos el mismo codigo que al ejemplo anterior, pero primero creamos un bloque try donde hacemos la creacion del objeto que abre el archivo, una particularidad es que pasamos solamente el archivo porque el metodo tiene como valor predeterminado la opcion para leer archivos de texto, es decir a rt, despues tenemos el mismo bloque encargado de mostrar las lineas del archivo, por ultimo tenemos el finally que unicamente cierra el archivo, la ventaja de trabajar de esta forma es que nos aseguramos al 100% que se cierra el archivo una vez realizado lo que contiene try ya que finally se ejecuta una vez terminado este bloque pero hay una mejor forma de tratarlo.

Usando un manejador de contexto

Si bien en el ejemplo anterior tenemos un muy buen codigo adminstrado por el bloque try/finally pero como siempre no es muy python ¯\_(ツ)_/¯, asi que utilizaremos una herramienta para reemplazarlo, usamos el siguiente codigo en el interprete:

>>> with open('prueba.txt') as fh:
...     for linea in fh:
...             print(linea.strip())
...

Como podemos ver este codigo hace exactamente lo mismo que el anterior pero con un codigo mas simple y de mejor lectura, esto es gracias a with dado que soporta el concepto de contexto de ejecucion definido por el manejador de contexto, esto se implementa por medio de dos metodos, __enter__ y __exit__, los cuales permiten a las clases definidas por usuario definir un contexto de ejecucion que es ingresado antes del bloque y se quita cuando se acaba el mismo, la funcion open es capaz de producir un objeto cuando es invocado por un manejador de contexto pero la verdadera magia es que fh.close() se llamara automaticamente cuando se termine incluso aunque finalice con error.

En resumen, hoy hemos visto como abrir un archivo, vimos como es su sintaxis mas basica para abrirlo, como procesarlo, como cerrarlo, despues vimos una forma de asegurarnos que el archivo sea liberado por medio de try/finally y por ultimo vimos el mismo ejemplo pero por medio de with, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.