Lenguajes. Python

Contenido de un directorio

Supongamos que deseo conocer el contenido de un determinado directorio cuya dirección localizo mediante la funcionalidad Propiedades de Documentos del sistema, que me devuelve D:/PROGRAMACION/OOoBasic/Documentos. Si deseo obtener información sobre el contenido de este directorio, incluyendo los archivos que lo forman y cuántos son éstos, el siguiente script Python me resuelve la tarea:

import os

#Accedo a directorio Documentos
os.chdir('D:/PROGRAMACION/OOoBasic/Documentos')
directorio_actual = os.getcwd()
print(f"Estoy en el directorio: {directorio_actual}")

#Listo los componentes del directorio
lista_archivos = os.listdir('.')

#... y cuento cuántos son
i = 0
for lista in lista_archivos:
	print(lista)
  	i = i + 1
print("Número total de archivos " + str(i))

Tras importar el módulo import os, me posiciono en el directorio mediante la función chdir() y confirmo mi posición mediante la función os.getcwd(). Ahora accedo al contenido del directorio mediante listdir('.') y, tomando como referencia la lista resultante lista_archivos = os.listdir('.'), la uso como iterable en for lista in lista_archivos: y aprovecho para listar los archivos print(lista) y para construir el sumatorio i = i + 1 que devuelve el número de elementos del directorio de trabajo print("Número total de archivos " + str(i)).

Python. Directorios.

Trabajo con directorios

Hemos visto en [Archivos] algunos de los usos que podemos hacer el módulo os y de otros de funcionalidad similar. Nos corresponde ahora plantear un procedimiento simple de uso combinado de algunas de sus funciones; aquellas que nos permitan hacer lo que necesitamos resolver con frecuencia: el posicionamiento y la creación de directorios como paso previo para la creación de documentos y el archivo controlado de los mismos.

En este caso vamos a plantear la realización de tareas previas de posicionamiento y creación de directorios mediante Python, motivo por el cual planteo como marco de trabajo la ubicación del script en el directorio escritorio y el desarrollo de los procedimientos de trabajo dentro de este directorio.

import os

# Obtener el directorio de trabajo actual
directorio_actual = os.getcwd()
print(f"Directorio actual: {directorio_actual}")

# Cambiar al directorio 'ejemplos' dentro del directorio actual
os.chdir('ejemplos')
# Obtener y mostrar el nuevo directorio de trabajo
nuevo_directorio = os.getcwd()
print(f"Nuevo directorio: {nuevo_directorio}")

# Volver al directorio anterior
os.chdir('..')
# Obtener y mostrar el directorio de trabajo después de volver
directorio_anterior = os.getcwd()
print(f"Directorio después de volver: {directorio_anterior}") 
 
#Nos posicionarnos en una ruta de directorio
os.chdir('C:/Users/alons/OneDrive/Escritorio/LECTURA')
print(os.getcwd()) 

Digo procedimientos en plural porque la idea es mostrar tres procedimientos simples. El primero, el anterior, muestra el modo en que resolvemos cuestiones relativas a nuestro posicionamiento dentro de directorios. Los dos que seguirán nos mostrarán procedimientos de creación de directorios. En cualquier caso, todos ellos inician con la instrucción import os, que es requisito previo, dado que todas las instrucciones son funciones de este módulo.

Pero veamos qué hacemos en el primero:

• Partimos de identificar en qué directorios nos encontramos (desde qué directorio estamos trabajando)...
• para lo que empleamos la función os.getcwd(), a la cual vamos a recurrir cada vez que deseemos comprobar el resultado de nuestro desplazamiento por los directorios...
• cosa que hacemos mediante la función os.chdir(), la cual admite como parámetro
• un subdirectorio del directorio actual (vg. os.chdir('ejemplos')),
• un manejador simple de posiciones (vg os.chdir('..'), que nos posiciona en el directorio inmediatamente superior al que nos encontramos)
• o una cadena de caracteres que expresa una dirección completa (vg. os.chdir('C:/Users/alons/OneDrive/Escritorio/LECTURA'))

También podemos crear un directorio mediante la función mkdir() en la posición o ruta en la que nos encontremos...

import os

# Crear un directorio simple

try:

    os.mkdir("mi_directorio")

    print("Directorio 'mi_directorio' creado.")

except FileExistsError:

    print("El directorio ya existe.")

... siendo posible controlar el correcto funcionamiento del script mediante el control de excepciones (try...except).

Pero en ocasiones (pronto veremos una) necesitamos automatizar la creación de un sistema de directorios anidados, cosa que podemos hacer recurriendo a la función anterior. Para esta tarea resulta mucho más adecuado hacer uso de la función makedirs(), como muestro en este script.

import os

# Crear un directorio anidado

try:

    os.makedirs("directorio_sup/directorio_med/directorio_inf")

    print("Estructura de directorios anidados creada.")

except FileExistsError:

    print("La estructura de directorios ya existe.")

Si te fijas, mientras mkdir() recibe como parámetro el nombre del directorio a crear (os.mkdir("mi_directorio")), makedirs() recibe una cadena compleja  (os.makedirs("directorio_sup/directorio_med/directorio_inf")). 

Pero ambas funciones comparten la conveniencia de usar un controlador de errores o excepciones (try except) y un comportamiento que puede que se nos pase por alto: haber creado el directorio o el sistema de directorios no implica que nos encontremos dentro de él o en uno de sus niveles; de hacho seguimos estando (seguimos posicionados) en el directorio desde el que los creamos, tal y como nos muestra (de nuevo) el uso de la función os.getcwd(). Si deseamos cambiar de posición deberemos recurrir, como antes explicamos, a la función os.chdir().

Python. Directorios.

 Operaciones con archivos

Trabajar con archivos es tan interesante como el trabajo con directorios, así que dedicamos esta entrada a mostrar algunas de las funciones os que nos permiten obtener información sobre archivos y operar con ellos.

En primer lugar vamos a obtener información relevante sobre un determinado archivo, esto es, algunos de sus metadatos. Para ello crearé un script a partir del ejemplo que muestra [certidevs].

import os

# Posicionamiento en el directorio

os.chdir('D:')

#Identificación confirmatoria como directorio activo

directorio = os.getcwd()

print(f"Ahora estamos en el  directorio: {directorio}")

#Identificación del archivo objeto de análisis 

archivo = 'archivo.pdf'

#Información sobre el nombre del archivo y sobre su existencia

print(f"Vamos a trabajar con el archivo: {archivo}")

print(f"Confirmación de existencia del archivo: {os.path.exists(archivo)}")

#Condicinalidad básica: de existir el archivo (metadatos) (if) y mensaje alternativo (else) 

if os.path.exists(archivo):

# Obtener el tamaño del archivo

    tamaño = os.path.getsize(archivo)

    print(f"Tamaño del archivo: {tamaño} bytes")  

# Obtener la última modificación (timestamp)

    tiempo_mod = os.path.getmtime(archivo)

# Convertir timestamp a fecha legible

    import datetime

    fecha_mod = datetime.datetime.fromtimestamp(tiempo_mod)

    print(f"Última modificación del archivo: {fecha_mod}")

# Comprobación de permisos

    es_legible = os.access(archivo, os.R_OK)

    es_escribible = os.access(archivo, os.W_OK)

    es_ejecutable = os.access(archivo, os.X_OK)

  print(f"Permisos sobre el archivo - Lectura: {es_legible}, Escritura: {es_escribible}, Ejecución: {es_ejecutable}")

else:

    print ("El archivo NO EXISTE")

En primer lugar importamos el módulo (import os) (1) y nos posicionamos en el directorio donde se ubica el archivo (os.chdir('D:')). Después realizamos varias comprobaciones e informaciones sobre directorio y archivo. Ahora nos interesa especialmente comprobar la existencia del archivo (print(f"Confirmación de existencia del archivo: {os.path.exists(archivo)}")), aunque, como veremos después, ya hemos dispuesto medidas dentro de la opcionalidad posterior (else).

Tras estas comprobaciones desarrollamos una estructura condicional (if os.path.exists(archivo):) (2) dentro de la cual obtenemos información sobre el tamaño del archivo (os.path.getsize()), la última  modificación del mismo (os.path.getmtime()) y una serie de datos sobre permisos (os.access()) (3) 

Mención especial requiere el procedimiento de conversión del metadato de fecha (de última modificación) (os.path.getmtime(archivo)) en una fecha legible para el usuario. Para ello se requiere recurrir al módulo datetime (import datetime) y a su función de conversión (datetime.datetime.fromtimestamp(tiempo_mod)). Ahora no vamos a tratar sobre este módulo (4), pero dejo indicado un posible tratamiento del mismo en otro momento.

Además de obtener información sobre un archivo, también podemos manipularlo, entendiendo por ello renombrarlo (os.rename()), moverlo a otro directorio (os.replace()) o eliminarlo (os.remove()); y todo ello desde el sistema, sin que sea necesario acceder a él (lectura-escritura). Veamos un sencillo script que da continuidad al anterior (5).

# Renombramos el archivo

os.rename('archivo.pdf', 'archivo_bis.pdf')

# Movemos el archivo

os.replace('archivo_bis.pdf','subdirectorio/archivo.pdf')

# Eliminamos el archivo

os.remove('archivo_copia.pdf')

Obsérvese que la función rename() requiere dos parámetros, bien como string, bien como variables (uno para el nombre antiguo del archivo y otro para el nuevo), al igual que la función replace() (en este caso el primero identifica el archivo a desplazar y el segundo requiere identificar el directorio (que debe existir) y el nombre (que puede ser diferente) del archivo que se desplaza. remove(), por el contrario, sólo requiere identificar el nombre del archivo que se va a eliminar.

NOTAS

(1) En buena lógica (y práctica de programación), ya que después importamos también el módulo datatime (import datetime) deberíamos realizar esta importación en este momento, pero por motivos didácticos la postponemos al momento en que resulta necesaria para la continuidad del script.

(2) Obsérvese que se mantiene el sangrado incluyendo dentro de la condición todas las instrucciones que siguen hasta else. 

(3) La función access() requiere dos parámetros, el nombre del archivo y la identificación del atributo específico de permiso o acceso. V.g. os.R_OK nos informa si el archivo es legible, esto es, si tiene permisos de lectura.

(4) El módulo datetime es de gran interés para nuestro trabajo dado que nos permite manipular fechas y horas. Información sobre el mismo en [este enlace]

(5) Damos por supuesto que existen los archivos y el directorio que se indican en las instrucciones. Aunque en este script no es imprescindible, en una formulación operativa del mismo el trabajo con el archivo debería condicionarse a la identificación previa de su existencia dentro del directorio en el que estemos trabajando, por lo que debería incluirse dentro de la primera parte del condicional.

Lenguajes. Python

Operaciones con directorios

Una de las utilidades del módulo os es el trabajo con directorios, así que dedicaré esta entrada a las funciones que nos permiten realizar estas operaciones.

Lo primero que vamos a hacer (1) es conocer en qué directorio estamos trabajando, esto es, en qué directorio se encuentra el archivo desde el que trabajamos. Para ello empleamos la función os.getcwd() que nos devuelve la ruta completa del directorio en que nos encontramos (2):

# Obtener el directorio de trabajo actual
directorio_actual = os.getcwd()
print(f"Estás en: {directorio_actual}")

Una vez que sabemos en qué directorio estamos situados, puede interesarnos acceder a otro diferente (3). Para ellos disponemos de la función os.chdir() a la que pasamos como parámetro el string del directorio al que deseamos acceder para, por ejemplo, crear en él un nuevo directorio; para ello empleamos la función os.mkdir(). Esto es lo que hace el siguiente script.

import os

# Obtenemos el directorio de trabajo inicial
directorio_inicial = os.getcwd()
print(f"Estás en: {directorio_inicial}")

# Cambiamos el directorio de trabajo y obtenemos su ruta
os.chdir('D:/ArchivosVarios')
directorio_actual = os.getcwd()
print(f"Y ahora estás en: {directorio_actual}")

# Y finalmente creamos un nuevo directorio en él
os.mkdir('nuevo_directorio')

También podemos eliminar un directorio, tanto si está vacío os.rmdir() como si no lo está, aunque para esto deberemos importar el módulo shutil, que debe ser usado con precaución (4).

# Módulo os. Elimina un directorio vacío
os.rmdir('nuevo_directorio')

# Módulo complementario para operaciones de archivos
import shutil

# ¡Cuidado! Elimina todo el contenido
shutil.rmtree('directorio_con_contenido')

Una vez que accedemos a un directorio nos puede interesar conocer qué subdirectorios y archivos contiene (listdir()), sólo qué archivos (isfile) o sólo qué directorios (isdir())...

#Ahora listamos los subdirectorios y archivos del directorio actual

lista_conten= os.listdir('.')	# '.' representa el directorio actual
print(f"Contenido del directorio: {lista_conten}") 

#Sólo mostramos los archivos

archivos = [f for f in lista_conten if os.path.isfile(f)]
print(f"Archivos: {archivos}")	

#Sólo mostramos los subdirectorios

directorios = [d for d in lista_conten if os.path.isdir(d)]
print(f"Directorios: {directorios}")

... aunque es posible que deseemos hacer un listado con información más detallada

for elemento in lista_conten:
	tipo = "Directorio" if os.path.isdir(elemento) else "Archivo"
    tamaño = os.path.getsize(elemento)	# Tamaño en bytes
    print(f"{elemento} - {tipo} - {tamaño} bytes")

Notas:

¹Realmente lo primero que haremos será importar el módulo os mediante la instrucción correspondiente (import os), pero esto lo damos por sabido.
²La segunda instrucción es la que nos devuelve por pantalla esa ruta. En otras ocasiones puede interesarnos conocerla para trabajar con ella, de ahí el interés por asociarla a una variable.
³La función getcwd() interesa para conocer desde donde se ejecuta nuestro script, pero necesitamos la función chdir() para navegar por el sistema de archivos.
⁴El módulo shutil permite realizar operaciones de alto nivel con archivos y colecciones de archivos, incluyendo la copia y el borrado de archivos y directorios. Su uso debe ser cuidadoso, ya que podemos eliminar accidentalmente archivos que no deseamos borrar.

Python. Directorios.

Módulo os

Aunque son varios los módulos Python para trabajar con el sistema operativo, iniicalmente vamos a trabajar con este módulo por su universalidad y por las funcionalidades que ofrece. El módulo os está preinstalado, por lo que no es necesario instalarlo mediante pip install, pero sí importarlo al inicio del script mediante import os. A partir de este momento tenemos a nuestra disposición...

• Obtener información del sistema operativo
• Acceder a variables del entorno del sistema
• Trabajar con rutas y directorios
• Listar directorios y archivos
• Ejecutar comandos del sistema
• Obtener información sobre metadatos de archivos
• Realizar operaciones con archivos
• Gestionar procesos del sistema operativo

El módulo os actúa como intermediario entre Python y el sistema operativo con el que trabajemos, facilitando la ejecución de operaciones que requieren comandos específicos, por lo que es fundamental para automatizar acciones que requieren interactuar con el sistema operativo.

En esta entrada y en las siguientes trataremos sobre las operaciones antes listadas que nos sean de utilidad para nuestros objetivos. Conforme las necesitemos para automatizar procesos, iré ampliando esta subsección del blog. Por ahora empezaré con las funciones que nos aportan información sobre el sistema y sobre sus variables.

import os

#Informa sobre qué sistema operativo se está usando
print(os.name)	#Devuelve nt para windows

#os.environ permite acceder a todas la variables de entorno
usuario = os.environ.get('USERPROFILE')	#Permite obtener el valor de una variable
print(usuario)

os.environ['MI_VARIABLE'] = 'valor'	# Permite establecer una nueva variable

for key, value in os.environ.items():	#Lista todas las variables de entorno
	print(f"{key}: {value}")
    

Notas

¹Para más información sobre os ver esta web. Además de os disponemos de otros módulos para trabajar con el sistema operativo: pathlib, sys, subprocess, io, y shutil. Con independencia de que sean tratados en entradas específicas, en la actual y en las que siguen hablaremos de aquellos que resulten pertinentes para determinadas operaciones.

²El módulo os ofrece una amplia gama de funciones para trabajar con el sistema operativo, con independencia de cuál sea éste. Para el desarrollo de esta entrada me basaré en certidevs, web muy interesante y didáctica.