Python. Directorios

Contenido de un directorio

En este momento necesito saber cuáles y cuantos son los componentes de un directorio. Para ello recurriré de nuevo al módulo os de Python.

Supongo 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() (1) y confirmo mi posición mediante la función os.getcwd().

El siguiente paso consiste en acceder al contenido del directorio mediante la función listdir('.') (2) y, tomando como referencia la lista a la que asigno dicho contenido (lista_archivos = os.listdir('.')), la utilizo como iterable en un ciclo for (for lista in lista_archivos:) que aprovecho para listar los archivos (print(lista)) y para construir un sumatorio sobre la variable i (i = i + 1) que devuelve el número de elementos que contiene el directorio sobre el que trabajamos (print("Número total de archivos " + str(i)))

NOTAS

(1) A la que paso como parámetro la cadena que obtuve antes con Propiedades de Documentos

(2) Cuyo parámetro hace referencia a dicho contenido.

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.

Python. Directorios

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 operar con directorios.

Lo primero que vamos a hacer (1) es conocer en qué directorio estamos trabajando, esto es: en qué directorio se encuentra el archivo .py desde el que solicitamos la información. Se trata, pues, de identificar el directorio en el que se encuentran los archivos que necesitamos en nuestro proyecto, uno de los cuales será, obviamente, el propio archivo .py. 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 lo que 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 preexistente, tanto si está vacío (os.rmdir())...

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

... como si no lo está, aunque para esto deberemos importar el módulo shutil, que debe ser usado con precaución (4).

import shutil  # Módulo complementario para operaciones de archivos

shutil.rmtree('directorio_con_contenido')  # ¡Cuidado! Elimina todo el 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

(1) Realmente lo primero que haremos será importar el módulo os mediante la instrucción correspondiente (import os), pero esto lo damos por sabido.
(2) 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. 
(3) La función getcwd() es interesante para conocer desde donde se ejecuta nuestro script, pero necesitamos la función chdir() para navegar por el sistema de archivos.
(4) 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 (1), de momento vamos a trabajar con el módulo os (2) por su universalidad y por las funcionalidades que ofrece.

El módulo os está preinstalado en Python, por lo que no es necesario  instalarlo, pero sí debemos 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 que siguen) trataremos sobre aquellas operaciones antes listadas que nos sean de utilidad para nuestros objetivos. Conforme las necesitemos para automatizar procesos, iré ampliando esta subsección del blog.

Empezaré ahora por 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

(1) 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.

(2) 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 lo que aporta [certidevs] en su web. Muy interesante y didáctica.