Entre los módulos de sistema que Python nos provee a través de su librería estándar, podemos destacar tres: os, sys, y subprocess. Haremos una breve reseña de cada uno de ellos, a continuación.
10.1.1. Módulo os
El módulo os nos permite acceder a funcionalidades dependientes del Sistema Operativo. Sobre todo, aquellas que nos refieren información sobre el entorno del mismo y nos permiten manipular la estructura de directorios (para leer y escribir archivos, ver capítulo 9). Referencia oficial.
10.1.1.1. Archivos y directorios
El módulo os nos provee de varios métodos para trabajar de forma portable con las funcionalidades del sistema operativo. Veremos a continuación, los métodos más destacados de este módulo.
| Descripción | Método |
|---|---|
| Saber si se puede acceder a un archivo o directorio | os.access(path, modo_de_acceso) |
| Conocer el directorio actual | os.getcwd() |
| Cambiar de directorio de trabajo | os.chdir(nuevo_path) |
| Cambiar al directorio de trabajo raíz | os.chroot() |
| Cambiar los permisos de un archivo o directorio | os.chmod(path, permisos) |
| Cambiar el propietario de un archivo o directorio | os.chown(path, permisos) |
| Crear un directorio | os.mkdir(path[, modo]) |
| Crear directorios recursivamente | os.mkdirs(path[, modo]) |
| Eliminar un archivo | os.remove(path) |
| Eliminar un directorio | os.rmdir(path) |
| Eliminar directorios recursivamente | os.removedirs(path) |
| Renombrar un archivo | os.rename(actual, nuevo) |
| Crear un enlace simbólico | os.symlink(path, nombre_destino) |
Para ver al módulo os trabajando con funcionalidades del sistema de archivos y directorios, ejecutar python os_examples de la carpeta sources de este capítulo.
10.1.1.2. El módulo os y las variables de entorno
El módulo os también nos provee de un diccionario con las variables de entorno relativas al sistema. Se trata del diccionario environ:
import os
for variable, valor in os.environ.iteritems():
print "%s: %s" % (variable, valor)10.1.1.3. os.path
El módulo os también nos provee del submódulo path (os.path) el cual nos permite acceder a ciertas funcionalidades relacionadas con los nombres de las rutas de archivos y directorios. Entre ellas, las más destacadas se describen en la siguiente tabla:
| Descripción | Método |
|---|---|
| Ruta absoluta | os.path.abspath(path) |
| Directorio base | os.path.basename(path) |
| Saber si un directorio existe | os.path.exists(path) |
| Conocer último acceso a un directorio | os.path.getatime(path) |
| Conocer tamaño del directorio | os.path.getsize(path) |
| Saber si una ruta es absoluta | os.path.isabs(path) |
| Saber si una ruta es un archivo | os.path.isfile(path) |
| Saber si una ruta es un directorio | os.path.isdir(path) |
| Saber si una ruta es un enlace simbólico | os.path.islink(path) |
| Saber si una ruta es un punto de montaje | os.path.ismount(path) |
Nota Para conocer más sobre os.path, visitar la documentación oficial.
10.1.2. Módulo sys
El módulo sys es el encargado de proveer variables y funcionalidades, directamente relacionadas con el intérprete.
10.1.2.1. Variables del módulo sys
Entre las variables más destacadas podemos encontrar las siguientes:
| Variable | Descripción |
|---|---|
sys.argv |
Retorna una lista con todos los argumentos pasados por línea de comandos. Al ejecutar python modulo.py arg1 arg2, retornará una lista: ['modulo.py', 'arg1', 'arg2'] |
sys.executable |
Retorna el path absoluto del binario ejecutable del intérprete de Python |
sys.maxint |
Retorna el número positivo entero mayor, soportado por Python |
sys.platform |
Retorna la plataforma sobre la cuál se está ejecutando el intérprete |
sys.version |
Retorna el número de versión de Python con información adicional |
10.1.2.2. Métodos del módulo sys
Entre los métodos más destacados del módulo sys, podemos encontrar los siguientes:
| Método | Descripción |
|---|---|
sys.exit() |
Forzar la salida del intérprete |
sys.getdefaultencoding() |
Retorna la codificación de caracteres por defecto |
sys.getfilesystemencoding() |
Retorna la codificación de caracteres que se utiliza para convertir los nombres de archivos unicode en nombres de archivos del sistema |
sys.getsizeof(object[, default]) |
Retorna el tamaño del objeto pasado como parámetro. El segundo argumento (opcional) es retornado cuando el objeto no devuelve nada. |
Nota Más información sobre el módulo sys, puede obtenerse en la documentación oficial.
10.1.3. Módulo subprocess
El módulo subprocess es aquel que nos permite trabajar de forma directa con órdenes del sistema operativo.
Advertencia El módulo subprocess** se presenta en este capítulo solo con fines educativos, mostrando ejemplos básicos y sencillos. Por lo tanto, se recomienda tener mucho cuidado en el uso de este módulo, desaconsejando su uso para órdenes que puedan comprometer el sistema**.
Entre los métodos más comunes de subprocess, podemos encontrar subprocess.call(). Este método, suele ser útil, para ejecutar órdenes sencillas, como por ejemplo, limpiar la pantalla:
from subprocess import call
call('clear')El método call, esperará recibir como primer argumento, el comando a ser ejecutado, como se mostró en el ejemplo anterior. Sin embargo, si el comando requiere argumentos, como primer parámetro, call necesitará recibir una lista donde el primer elemento será el comando y el segundo, sus argumentos. Un ejemplo de ello, es el siguiente código encargado de hacer un listado de archivos y directorios:
from subprocess import call
comando_y_argumentos = ['ls', '-lha']
call(comando_y_argumentos)El módulo subprocess también nos provee del submódulo Popen, el cuál nos permite, no solo ejecutar órdenes al igual que call, sino mantener un mejor control sobre las salidas.
10.1.3.1. Capturando la salida con Popen
El manejo y captura de las salidas, puede resultar un poco complejo. Por eso, intentaremos explicarlo paso a paso a fin de evitar confusiones.
Lo primero que debemos tener en cuenta, es que Popen (al igual que call), como primer argumento, recibirá el comando a ser ejecutado o una lista de dos elementos, donde el primero sea el comando y el segundo, la lista de argumentos. Hasta aquí, no hay diferencia con call. Sin embargo, si la salida del proceso abierto con Popen no es tratada, el proceso quedará abierto.
Por ejemplo, el siguiente código quedaría en ejecución:
from subprocess import Popen
Popen(['ls', '-lha']A diferencia de call, Popen no es un método de subprocess, sino, un objeto. Cómo tal, la forma correcta de iniciar un proceso con Popen, será entonces, crear un objeto Popen para poder acceder a sus métodos, y así evitar, que el proceso quede abierto en ejecución. De esta forma, creamos el objeto y luego, llamamos al método wait() de Popen, el cual espera a que el proceso finalice.
from subprocess import Popen
proceso = Popen(['ls', '-lha'])
proceso.wait()Si ejecutamos el código anterior, al igual que sucede con call, la salida obtenida es directamente plasmada en pantalla. Es aquí donde entra en juego, el manejo de las salidas que Popen nos permite hacer.
10.1.3.2. Entradas y salidas que pueden ser capturadas con Popen
- stdout: nomenclatura correspondiente a la salida estándar en sistemas UNIX-Like. Es la encargada de almacenar la salida de un programa.
- stdin: nomenclatura correspondiente a la entrada estándar en sistemas UNIX-like. Es la encargada de enviar información a un programa.
- stderr: al igual que las anteriores, se utiliza como referencia a los errores producidos en la salida de un programa.
10.1.3.3. Utilizando tuberías para capturar la salida
Popen nos permite capturar tanto la entrada como la salida estándar o su error. Para efectuar dicha captura, tanto stdout como stdin y/o stderr se pasan como argumentos clave a Popen. El valor de dichos argumentos, deberá ser un archivo o una tubería que funcione como tal. Y para esto, Popen, también nos provee de una tubería para capturar dichas entradas y salidas, llamada PIPE.
De esta forma, si quisiéramos capturar la salida estándar o error de nuestro código, debemos pasarle a Popen, stdout y stderr como argumentos claves, con PIPE como valor de cada uno de ellos, para lo cual, también debemos importar PIPE:
from subprocess import PIPE, Popen
proceso = Popen(['ls', '-lha'], stdout=PIPE, stderr=PIPE)Al capturar la salida estándar en una tubería, ya no será necesario poner en espera al proceso, puesto que directamente será capturado por la tubería, permitiéndonos acceder a la lectura tanto de stdout como de stderr, como si se tratara de cualquier otro archivo:
proceso = Popen(['ls', '-lha'], stdout=PIPE, stderr=PIPE)
error_econtrado = proceso.stderr.read()
listado = proceso.stdout.read()Capturando la salida, como bien se puede ver en el ejemplo, stdout y stderr, son tratados como archivos (de hecho, lo son ya que hemos utilizado una tubería). Por lo tanto, deben ser cerrados una vez leídos:
proceso = Popen(['ls', '-lha'], stdout=PIPE, stderr=PIPE)
error_econtrado = proceso.stderr.read()
proceso.stderr.close()
listado = proceso.stdout.read()
proceso.stdout.close()Luego, podremos manipular dichas lecturas, como cualquier string:
if not error_encontrado:
print listado
else:
print "Se produjo el siguiente error:\n%s" % error_encontradoNota Para conocer más sobre subprocess, ingresar en la documentación oficial.