Python / Trabajando con directorios

Bienvenidos sean a este post, antes vimos como trabajar con archivo pero hoy nos centraremos en directorios.

Manipulando directorios

Hasta aqui vimos como trabajar de distintas formas con archivos pero a partir de aca nos centraremos en como hacerlo sobre los directorios y para entender el primer concepto vamos a hacer un simple ejemplo donde primero importaremos los siguiente modulos:

>>> import shutil
>>> import os

El primero nos permitira trabajar de mejor forma sobre los archivos y directorios en alto nivel y el segundo es para poder trabajar mejor con opciones del sistema operativo, con esto realizado vamos a crear nuestro directorio base para trabajar:

>>> PATH_BASE = 'ejemplo_ops'
>>> os.mkdir(PATH_BASE)

Primero estableceremos cual es el nombre que sera nuestro directorio base del cual comenzaremos a crear el resto, lo siguiente sera utilizar a mkdir de os para crear el directorio almacenado en PATH_BASE, si lo ejecutan y no devuelve ningun error significa que ya esta creado, pasemos a crear una serie de paths para hacer unos nuevos directorios:

>>> path_b = os.path.join(PATH_BASE, 'A', 'B')
>>> path_c = os.path.join(PATH_BASE, 'A', 'C')
>>> path_d = os.path.join(PATH_BASE, 'A', 'D')

En este caso tenemos tres variables iguales pero en estas guardaremos tres paths distintos aunque se crean de la misma forma, usaremos a path de os y por medio de join le pasaremos el directorio raiz, luego el directorio principal seguido del directorio que sera contenido por los anteriores, con estas tres variables podemos pasar al proximo paso:

>>> os.makedirs(path_b)
>>> os.makedirs(path_c)

En este caso crearemos todos los subdirectorios que definimos anteriormente pero en lugar de usar mkdir usaremos a makedirs para poder crear todos los directorios, como siempre sino devuelve un error quiere decir que se ejecuto correctamente, para nuestro siguiente paso usaremos el siguiente codigo:

>>> for archivo in ('ex1.txt','ex2.txt','ex3.txt'):
...     with open(os.path.join(path_b, archivo), 'w') as flujo:
...             flujo.write(f'Algun contenido en {archivo}\n')
... 
27
27
27
>>>

En este bloque usaremos un bucle for donde pasara por una lista y esto lo almacenaremos en una variable llamada archivo, luego usaremos un open con with para crear un archivo, donde pasaremos el path almacenado en path_b y el nombre del archivo contenido en archivo, y dentro escribiremos un texto, con la f le daremos un formato al texto y en este caso es el nombre del archivo en cuestion, una vez ejecutado nos devolvio la correcta de creacion de los mismos, con esto tenemos tres archivos dentro del directorio B en el directorio A, vamos a ejecutar la siguiente linea:

>>> shutil.move(path_b, path_d)
'ejemplo_ops/A/D'
>>>

Cambiamos de elemento importado, en este caso usamos a shutil y el metodo move, el cual se encargara de mover el archivo o directorio de un lugar a otro, para el ejemplo hemos dicho que mueva todo el contenido del directorio B al directorio D, esto lo haria si existiese D pero al no existir lo que en realidad ejecuto fue cambiar el nombre de B a D, dado que estan dentro del mismo directorio, observen la salida que nos dio, indicando cual fue el destino final, ahora vamos a probar lo mismo pero con un archivo:

>>> shutil.move(
...     os.path.join(path_d, 'ex1.txt'),
...     os.path.join(path_d, 'ex1d.txt')
... )
'ejemplo_ops/A/D/ex1d.txt'
>>>

En este caso ejecutamos de nueveo move pero para un archivo, si observan bien en realidad no hizo ningun movimiento sino que en realidad cambio el nombre del archivo, nos muestra como se cambio el nombre del mismo para notificarnos que salio todo correcto, veamos todos los cambios que realizamos

ejemplo_ops/
└── A
    ├── C
    └── D
        ├── ex1d.txt
        ├── ex2.txt
        └── ex3.txt

Observen que tenemos todos los cambios realizados, la estructura el cambio de directorio con su contenido y el cambio de nombre del archivo, pasemos al siguiente tema.

Manipulando los paths

Nosotros podemos manejar los paths de un archivo con os.path pero para entenderlo mejor usaremos el siguiente ejemplo, primero importemos a os:

>>> import os

Lo siguiente sera establecer el archivo y su path:

>>> archivo = "prueba.txt"
>>> path = os.path.abspath(archivo)

Nota:
Este archivo es el utilizado en posts anteriores o simplemente generen uno en blanco.

Crearemos una variable con el nombre del archivo en cuestion y en la segunda sera mas un objeto que contendra con todo el path del archivo que creamos anteriormente, vamos a probar un par de propiedades de path:

>>> print(os.path.dirname(path))
/home/tinchicus/lenguajes/python
>>>

Esta propiedad nos devolvera el path o la ruta de directorios de nuestro archivo, probemos con la siguiente propiedad:

>>> print(os.path.splitext(path))
('/home/tinchicus/lenguajes/python/prueba', '.txt')
>>>

Esta propiedad nos separa un texto, en este caso solamente la extension del archivo, probemos la siguiente:

>>> print(os.path.split(path))
('/home/tinchicus/lenguajes/python', 'prueba.txt')
>>>

Esta nos separa el path del archivo para trabajarlos por separado, para nuestra siguiente prueba crearemos una nueva variable con el siguiente codigo:

>>> path_rst = os.path.join(os.path.dirname(path),
...     '..', '..', 'prueba.rst')

Para este caso usaremos a join para unir el dirname de nuestro path, le pasaremos dos veces los dos puntos (..) para que baje dos directorios y luego el nombre de nuestro archivo con la extension .rst, probemos de mostrar el contenido:

>>> print(path_rst)
/home/tinchicus/lenguajes/python/../../prueba.rst
>>>

Como vemos se realizo la tarea solicitada pero podemos dejarlo mas monono, para ello usaremos la siguiente propiedad:

>>> print(os.path.normpath(path_rst))
/home/tinchicus/prueba.rst
>>>

Como vemos nos transforma al path como corresponde, con esto concluimos con la manipulacion de los path de los archivos, pasemos al siguiente tema.

Archivos y directorios temporales

Cuando hablamos de temporales nos referimos a justamente eso, algo que existira por un determinado tiempo, y podemos tener situaciones donde no necesitamos un elemento en el disco sino simplemente crear un elemento (directorio o archivo) temporal para verificar la logica del codigo y que este sea eliminado cuando se termine el mismo, python nos provee una herramienta para trabajar asi, veamos el siguiente ejemplo:

>>> import os
>>> from tempfile import NamedTemporaryFile, TemporaryDirectory

Primero importaremos a os, luego dos metodos de la clase tempfile, el primero sera para manejar archivos temporales y el segundo para el directorio temporal, pasemos a trabajar con los elementos temporales mediante el siguiente codigo:

>>> with TemporaryDirectory(dir='.') as dt:
...     print('Directorio temporal:', dt)
...     with NamedTemporaryFile(dir=dt) as t:
...             nombre = t.name
...             print(os.path.abspath(nombre))
...

Por medio del with trabajaremos primero con TemporaryDirectory donde pasaremos un valor predeterminado y lo identificaremos como dt, dentro de este bloque mostraremos cual es el valor de dt, es decir nuestro directorio temporal, lo siguiente es otro with pero para trabajar con NamedTemporaryFile donde le pasaremos el directorio temporal donde debe trabajar y a este lo almacenaremos en t, lo siguiente sera crear e iniciar una nueva variable llamada nombre donde almacenaremos el nombre temporal asignado, por ultimo mostraremos todo el path donde fue generado dicho archivo, veamos su salida:

Directorio temporal: ./tmpzrf81k56
/home/tinchicus/lenguajes/python/tmpzrf81k56/tmpauyvw_ek
>>>

Como pueden ver se crearon dos elementos con identificaciones que dificilmente coincida con algunos de los archivos que podamos crear pero una vez terminado ambos procesos estos desapareceran, espero se haya entendido pasemos al siguiente tema.

Contenido del directorio

Como se imaginan tambien podemos mostrar el contenido de un directorio, veamos la primera forma:

>>> import os
>>> with os.scandir('.') as it:
...     for entrada in it:
...             print(entrada.name, entrada.path,
...             'Archivo' if entrada.is_file() else 'Directorio')
...

Como siempre primero importamos a os, luego usaremos a scandir para mirar el directorio, en este caso le pasamos nuestro directorio de trabajo actualmente y lo asignamos al objeto it, despues usaremos un bucle for para pasar por todo el objeto iterable, en este mostraremos primero el nombre de la entrada, seguido del path y especificaremos si se trata de un Archivo o un Directorio mediante el is_file del condicional, si lo probamos veremos lo siguiente:

Nota: 
La salida que veremos a continuacion puede diferir de la ustedes.

abrir.py ./abrir.py Archivo
prueba_copia.txt ./prueba_copia.txt Archivo
copiar.py ./copiar.py Archivo
args.py ./args.py Archivo
__pycache__ ./__pycache__ Directorio
alcances.py ./alcances.py Archivo
clave.py ./clave.py Archivo
scopes.py ./scopes.py Archivo
abeurp.txt ./abeurp.txt Archivo
while.py ./while.py Archivo
compress.py ./compress.py Archivo
estatico.py ./estatico.py Archivo
prueba.txt ./prueba.txt Archivo
herencia.py ./herencia.py Archivo
chequeo.herencia.py ./chequeo.herencia.py Archivo
mutable.py ./mutable.py Archivo
estudiantes.py ./estudiantes.py Archivo
else.py ./else.py Archivo
rangos.py ./rangos.py Archivo
ejemplo.bin ./ejemplo.bin Archivo
ejemplo.x.txt ./ejemplo.x.txt Archivo
argumentos.py ./argumentos.py Archivo
atributos.py ./atributos.py Archivo
iterador.py ./iterador.py Archivo
ejemplo ./ejemplo Directorio
hola.py ./hola.py Archivo
ejemplo.txt ./ejemplo.txt Archivo
primos.py ./primos.py Archivo
cuentas ./cuentas Directorio
ejemplo_ops ./ejemplo_ops Directorio
>>>

Como pueden ver esta es una forma basica de obtener todo el contenido de un directorio pero hay otra alternativa, pasemos a ver el siguiente ejemplo:

>>> import os
>>> for raiz, dirs, archivos in os.walk('./ejemplo_ops'):
...     print(os.path.abspath(raiz))
...     if dirs:
...             print('Directorios:')
...             for directorio in dirs:
...                     print(directorio)
...             print()
...     if archivos:
...             print('Archivos:')
...             for archivo in archivos:
...                     print(archivo)
...             print()
...

En este caso usaremos a walk en lugar de scandir, este metodo nos permitira pasar por todos los contenidos que tengan el directorio que pasamos, observen que pase el creado al principio de este post, todo esto gracias a un for donde almacenaremos el raiz, los directorios y los archivos, lo primero que haremos sera mostrar el path absoluto de raiz, luego tenemos dos condicionales donde el primero sera para los directorios que tenga el directorio, mostramos un titulo para identificarlos y luego todos los contenidos en dirs, mostramos un espacio en blanco, el siguiente condicional es para verificar los archivos, mostramos el rotulo e igual al caso anterior donde mostraremos los archivos del directorio, veamos el resultado:

/home/tinchicus/lenguajes/python/ejemplo_ops
Directorios:
A

/home/tinchicus/lenguajes/python/ejemplo_ops/A
Directorios:
D
C

/home/tinchicus/lenguajes/python/ejemplo_ops/A/D
Archivos:
ex1d.txt
ex2.txt
ex3.txt

/home/tinchicus/lenguajes/python/ejemplo_ops/A/C
>>>

Este no es mas practico que el anterior pero si nos devuelve mas informacion si se sabe manejar, pasemos a hablar sobre el ultimo tema.

Compresion de archivos y directorios

Una gran particularidad de python es que nos permite manejar archivos comprimidos para almacenar tanto archivos como directorios, existen varios tipos de formato pero en este caso veremos al mas generico y difundido como es ZIP, veamos que debemos importar:

>>> from zipfile import ZipFile

Con esto importaremos el metodo que usaremos para crear nuestro archivo, pasemos a crear el primero:

Nota: 
Yo usare archivos que tengo en mi directorio pero traten de usar los que tengan disponibles

>>> with ZipFile('ejemplo_ops/ejemplo.zip','w') as zp:
...     zp.write('abeurp.txt')
...     zp.write('abrir.py')
...     zp.write('ejemplo_ops/A/D/ex1d.txt')
... 
>>>

Como siempre usamos a with para cerrar nuestra operacion con ZipFile y le pasamos donde crearemos el archivo, en este caso utilizo el directorio de ejemplo creado en este post, seguido del nombre del archivo y lo direccionamos a un objeto llamado zp, luego por medio de write ingresaremos los archivos a comprimir dentro de este, vean que podemos simplemente el nombre del archivo si estamos en el mismo directorio o todo el path para encontrarlo, podemos agregar todo los que sean necesarios, si lo chequeamos veremos que se ha creado correctamente:

tinchicus@dbn001vrt:~/lenguajes/python$ ls -l ejemplo_ops/
total 8
drwxr-xr-x 4 tinchicus tinchicus 4096 abr 14 15:02 A
-rw-r--r-- 1 tinchicus tinchicus 1324 abr 14 18:42 ejemplo.zip
tinchicus@dbn001vrt:~/lenguajes/python$

Antes de finalizar veamos como extraer los archivos de este archivo, para ello deberemos usar el siguiente codigo:

>>> with ZipFile('ejemplo_ops/ejemplo.zip') as zp:
...     zp.extract('abeurp.txt', 'extracto_zip')
...     zp.extract('ejemplo_ops/A/D/ex1d.txt','extracto_zip')
... 
'extracto_zip/abeurp.txt'
'extracto_zip/ejemplo_ops/A/D/ex1d.txt'
>>>

Volvemos a usar el with con ZipFile pero sin enviar la opcion w y repetimos el mismo archivo anterior, volvemos a usar el mismo objeto (zp) y despues en este objeto usaremos extract donde le pasaremos el nombre del archivo a extraer seguido del directorio donde lo haremos sino lo informamos lo hara donde esta el archivo, en este caso tomamos uno en el raiz del archivo y otro dentro de una serie de directorios, tambien le pasamos el mismo directorio, si vemos nos notificara que los dos archivos fueron extraidos, veamos como quedo dicha salida:

extracto_zip/
├── abeurp.txt
└── ejemplo_ops
    └── A
        └── D
            └── ex1d.txt

Con esto concluimos como crear archivos comprimidos y como extraer el contenido de los mismos.

En resumen, hoy hemos visto las distintas formas de trabajo en directorios con python, desde lo mas basico como es crearlos hasta moverlos, tambien hemos visto como conseguir la informacion de los mismos, tambien como trabajar con archivos y directorios temporales para nuestro codigo, por otro lado hemos visto como mostrar el contenido de una forma simple y otra mas compleja pero con mas informacion y finalmente como trabajar para comprimir archivos y poder extraer su informacion, 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.