Cómo obtener el directorio actual en Python

Muchos programas Python necesitan navegar por el sistema de archivos para leer y escribir archivos. Una operación habitual es obtener el directorio de trabajo actual, que suele abreviarse como CWD.

Python tiene dos módulos principales que pueden utilizarse para acceder a las rutas del sistema de archivos: elmódulo os y el módulo pathlib .

El módulo os ofrece el enfoque tradicional para obtener el directorio de trabajo actual y trabaja con rutas y el sistema de archivos.

pathlib es un módulo más reciente que ofrece un enfoque orientado a objetos, robusto y multiplataforma.

En este tutorial, exploro las distintas técnicas para obtener y manipular el directorio de trabajo actual. Si quieres saber más sobre Python, no dudes en explorar otras entradas de mi blog:

• Caché de Python: Dos métodos sencillos
• Python timedelta: Trabajar con intervalos de tiempo en Python
• Cómo convertir cadenas en bytes en Python

Pitón: Cómo obtener el Directorio de Trabajo Actual (CWD)

El directorio de trabajo actual es el directorio en el que se ejecuta un programa Python. Sirve como punto de referencia para las rutas relativas de los archivos y permite al programa acceder a archivos y recursos dentro de la jerarquía de directorios.

Veamos cómo acceder al directorio de trabajo actual utilizando los módulos os y pathlib y comparemos las dos soluciones.

Utilizando os.getcwd()

El módulo os permite acceder al sistema operativo del ordenador. La función getcwd() obtiene el directorio de trabajo actual:

import os
cwd = os.getcwd()
print(cwd)

/Users/sg/Documents/GitHub/datacamp

La salida muestra la ruta del directorio que contiene el script. El formato de la ruta depende del sistema operativo. La salida anterior es para sistemas operativos POSIX como Linux, Unix y macOS.

La misma ruta en un sistema Windows se mostraría así:

C:\Users\sg\Documents\GitHub\datacamp

El valor devuelto por os.getcwd() es una cadena:

print(type(cwd))

<class 'str'>

Por lo tanto, tenemos que utilizar métodos de cadena y otras operaciones de cadena para tratar este camino.

Utilizando pathlib.Path.cwd()

Python 3.4 introdujo el módulo pathlib, que ofrece un enfoque orientado a objetos para acceder y manipular rutas de archivos. La clase principal de pathlib es Path, que podemos importar antes de obtener el directorio de trabajo actual:

from pathlib import Path
cwd = Path.cwd()
print(cwd)

/Users/sg/Documents/GitHub/datacamp

La salida impresa de Path.cwd() tiene un aspecto similar al valor devuelto por os.getcwd(). Sin embargo, Path.cwd() no devuelve una cadena. Podemos confirmarlo imprimiendo el tipo del objeto devuelto o mostrando su representación oficial en cadena mediante repr():

print(type(cwd))
print(repr(cwd))

<class 'pathlib.PosixPath'>
PosixPath('/Users/sg/Documents/GitHub/datacamp')

En un ordenador Windows, Path.cwd() devuelve un objeto WindowsPath.

Los objetos PosixPath y WindowsPath proporcionan una funcionalidad similar para permitir programas multiplataforma. Estos son algunos de los atributos de estos objetos:

print(cwd.parent)
print(cwd.name)

/Users/sg/Documents/GitHub
datacamp

Siempre que sea posible, es preferible utilizar el módulo pathlib, que es más moderno y facilita el manejo de las rutas. Puedes leer esta guía completa sobre el uso de pathlib en Python si quieres saber más.

Trabajar con el directorio actual

Los programas Python a menudo necesitan manipular la ruta, por ejemplo, para guardar un archivo en una subcarpeta. Supongamos que necesitamos crear un nuevo subdirectorio en nuestro directorio de trabajo actual y guardar un archivo de texto en la nueva carpeta.

Utilizando la os módulo

La función getcwd() del módulo os devuelve una cadena. Por tanto, es posible alterar manualmente esta cadena para modificar la ruta. Sin embargo, las modificaciones necesarias varían en función del sistema operativo, ya que los distintos sistemas tienen formatos de ruta diferentes. Una opción mejor es utilizar os.path.join():

import os
cwd = os.getcwd()
output_path = os.path.join(cwd, "testing_os")
print(output_path)

/Users/sg/Documents/GitHub/datacamp/testing_os

La ruta que devuelve os.path.join() tiene el formato correcto para el sistema operativo utilizado. Devuelve una cadena con la nueva ruta. Podemos comprobar si esta subcarpeta existe con os.path.exists(), que devuelve un booleano:

print(os.path.exists(output_path))

False

Esto demuestra que la ruta representada por output_path aún no existe. El módulo os proporciona herramientas para crear esta carpeta. La función os.mkdir() crea un nuevo directorio:

os.mkdir(output_path)
print(os.path.exists(output_path))

True

Ahora existe la nueva subcarpeta y se pueden guardar nuevos archivos en ella:

output_file = os.path.join(output_path, "test.txt")
with open(output_file, "w") as file:
    file.write("Testing path modification with the 'os' module")

La variable output_file contiene el nombre del archivo de salida deseado con la ruta completa. Este archivo de texto se crea en la subcarpeta /testing_os dentro del directorio de trabajo actual.

También podemos listar todos los elementos de una carpeta utilizando os.listdir():

for item in os.listdir(output_path):
    print(item)

test.txt

La función os.listdir() devuelve una lista con todos los elementos del directorio. Este código recorre esta lista para mostrar cada archivo o carpeta en una línea distinta. En este ejemplo, el directorio contiene un único archivo de texto.

Utilizando la pathlib módulo

El nuevo módulo pathlib también proporciona herramientas para crear nuevas rutas. Este módulo utiliza el operador de barra diagonal / para combinar elementos en una ruta. Es el mismo operador que se utiliza para la división de tipos de datos numéricos, pero también es el carácter utilizado en las rutas de archivos en los sistemas operativos POSIX. Vamos a crear una nueva ruta y a comprobar que no existe ya:

from pathlib import Path
cwd = Path.cwd()
output_path = cwd / "testing_pathlib"
print(output_path)
print(Path.exists(output_path))

/Users/sg/Documents/GitHub/datacamp/testing_pathlib
False

La clase Path tiene su propio método .mkdir() para crear un nuevo directorio:

Path.mkdir(output_path)
print(Path.exists(output_path))

True

Como output_path es un objeto PosixPath o WindowsPath, podemos utilizar el operador de barra oblicua en cualquier lugar para crear una nueva ruta:

with open(output_path / "test.txt", "w") as file:
    file.write("Testing path modification with the 'pathlib' module")

El nuevo archivo de texto se crea en la carpeta /testing_pathlib.

Podemos utilizar el método Path .iterdir() para iterar por cada elemento de una carpeta:

for item in Path.iterdir(output_path):
    print(item)

/Users/sg/Documents/GitHub/datacamp/testing_pathlib/test.txt

Como ocurre con otras herramientas de pathlib, el valor devuelto no es una cadena. En su lugar, es un objeto PosixPath o WindowsPath. Podemos utilizar el atributo .name para mostrar el nombre del archivo o carpeta sin la ruta completa:

for item in Path.iterdir(output_path):
    print(item.name)

test.txt

Mientras que os.listdir() devuelve una lista, pathlib.Path.iterdir() devuelve un objeto generator (puedes leer este tutorial sobre Iteradores y generadores de Python si necesitas un repaso):

print(Path.iterdir(cwd))

<generator object Path.iterdir at 0x1036b2c20>

Este comportamiento sigue las mejores prácticas del Python moderno, ya que los iteradores y generadores son más eficientes en determinadas situaciones.

Cambiar el directorio de trabajo actual (CWD)

También es posible cambiar el directorio de trabajo actual directamente desde dentro de un programa Python utilizando os.chdir(). Como no se trata de una operación directamente relacionada con la ruta, no existe una versión alternativa en pathlib. Sin embargo, podemos seguir utilizando objetos pathlib.Path como argumentos:

import os
from pathlib import Path
cwd = Path.cwd()
print(cwd)

os.chdir(cwd.parent)
cwd = Path.cwd()
print(cwd)

/Users/sg/Documents/GitHub/datacamp
/Users/sg/Documents/GitHub

El directorio de trabajo ha cambiado. También podemos utilizar cwd.parent.resolve() para asegurarnos de que los enlaces simbólicos se tratan correctamente. El argumento en os.chdir() también puede ser una cadena, como las rutas devueltas por las funciones del módulo os.

Hay que tener cuidado al cambiar el directorio de trabajo dentro de un programa para asegurarse de que no se producen comportamientos inesperados.

Buenas prácticas y consejos

Aquí tienes algunas buenas prácticas y consejos para trabajar con rutas en Python:

Conclusión

Navegar y manipular rutas de archivos es un requisito habitual en muchos programas Python. El módulo os proporciona las funciones tradicionales para manejar estas tareas, mientras que el módulo pathlib ofrece un enfoque más moderno, orientado a objetos. Utilizar pathlib no sólo simplifica muchas operaciones, sino que también garantiza que tu código siga siendo multiplataforma y más fácil de leer.

Tanto si mantienes una base de código existente que utiliza os como si empiezas un nuevo proyecto en el que puedes aprovechar pathlib, comprender ambos módulos y sus capacidades te dará la flexibilidad y confianza necesarias para gestionar las rutas en cualquier proyecto Python.

Puedes continuar tu viaje de aprendizaje de Python con estos cursos:

• Curso de Introducción a Python
• Curso de Introducción a las Pruebas en Python
• Curso de Web Scraping con Python