Ver índice de contenidos del libro

10.1. Módulos de sistema

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_encontrado

Nota Para conocer más sobre subprocess, ingresar en la documentación oficial.

Copyright (c) 2011-2013 Eugenia Bahit. La copia y redistribución de esta página se permite bajo los términos de la licencia Creative Commons Atribución NoComercial SinDerivadas 3.0 Unported siempre que se conserve esta nota de copyright.