Como ya vimos anteriormente con algunos módulos como por ejemplo, random. Desde la biblioteca de Python podemos importarnos multitud de módulos. En este capítulo vamos a ver algunos módulos de python encargados de diferentes funciones que nos harán mucho más sencillo el día a día.
Módulo os
El módulo os nos permite acceder a funcionalidades dependientes del Sistema Operativo. Vamos a empezar explicando cómo trabajar con archivos y directorios, tal y como comentamos en el capítulo anterior.
Lo primero de todo, para importar este módulo, lo haríamos de la siguiente forma
1 |
import os |
A la hora de trabajar con ficheros, este módulo nos provee de varios métodos con los que trabajar con diferentes funciones del OS. En la siguiente tabla podemos ver los métodos más destacados para trabajar con ficheros
Comando |
Descripción |
os.access(path, modo_de_acceso) |
Conocer si tenemos permisos para acceder a un fichero o directorio |
os.getcwd() |
Conocer el directorio actual |
os.chdir(nuevo_path) |
Cambiar de directorio de trabajo |
os.chroot() |
Cambiar al directorio de trabajo raíz |
os.chmod(path, permisos) |
Cambiar los permisos de un fichero o directorio |
os.chown(path, permisos) |
Cambiar el propietario de un fichero o directorio |
os.mkdir(path[, modo]) |
Crear un directorio nuevo |
os.mkdirs(path[, modo]) |
Crear directorios recursivamente |
os.remove(path) |
Eliminar un fichero |
os.rmdir(path) |
Eliminar un directorio |
os.removedirs(path) |
Eliminar directorios recursivamente |
os.rename(actual, nuevo) |
Renombrar un fichero |
os.symlink(path, nombre_destino) |
Crear un enlace simbólico |
Otra gran utilidad de este módulo, es el diccionario environ, con el cual podemos acceder a las variables de entorno relativas al sistema en el cual ejecutemos nuestro programa. Podemos ver un ejemplo:
1 2 3 |
import os for variable, valor in os.environ.items(): print("%s: %s" % (variable, valor)) |
También tenemos a nuestra disposición el submódulo path (os.path), el cual nos permite acceder a funcionalidades relacionadas con los nombres de ruta de ficheros y directorios.
Podemos ver las más utilizadas en la siguiente tabla
Comando |
Descripción |
os.path.abspath(path) |
Ruta absoluta |
os.path.basename(path) |
Directorio base |
os.path.exists(path) |
Conocer si un directorio existe |
os.path.getatime(path) |
Conocer el último acceso a un directorio |
os.path.getsize(path) |
Conocer el tamaño de un directorio |
os.path.isabs(path) |
Saber si una ruta es absoluta |
os.path.isfile(path) |
Saber si la ruta corresponde a un fichero |
os.path.isdir(path) |
Saber si la ruta corresponde a un directorio |
os.path.islink(path) |
Saber si la ruta corresponde a un enlace simbólico |
os.path.ismount(path) |
Saber si la ruta es un punto de montaje |
Si queréis más información acerca del módulo os, podéis visitar la documentación oficial.
Módulo sys
El módulo sys será el encargado de proveernos de las variables y funcionalidades con las cuales trabajará el intérprete.
Entre las variables podemos destacar 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 que soporte Python |
sys.platform |
Retorna la plataforma sobre la cual se está ejecutando el intérprete |
sys.version |
Retorna el número de versión de Python con información adicional |
Además de las variables, el módulo sys tiene algunas funciones destacadas como las siguientes:
Método |
Descripción |
sys.exit() |
Fuerza 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. |
Además podemos ver más información del módulo sys en la página de la documentación oficial.
Módulo subprocess
El módulo subprocess nos permite trabajar de forma directa con órdenes del sistema operativo. Es importante tener cuidado con las acciones que realicemos utilizando este módulo porque, podemos realizar casi cualquier acción en el sistema siempre que dispongamos de los permisos apropiados para ello. Cabe destacar, que presentamos este módulo sólo con fines educativos, por lo que cualquier acción aprendida con este curso es responsabilidad de aquel que la realice.
Aclarado este punto, vamos a explicar uno de los métodos más comunes, call(), que podemos ver con un sencillo ejemplo:
1 2 |
from subprocess import call call('clear') |
En este ejemplo, borramos la pantalla de nuestra consola en máquinas Linux. Vamos a ver algo más complejo, en este segundo ejemplo, vamos a pasarle dos argumentos al método call. Para ello, tendremos que pasarle por parámetro una lista cuyo primer elemento será el comando a ejecutar, seguido de los argumentos.
1 2 3 |
from subprocess import call comando = ['ls', '-la'] call(comando) |
En este ejemplo lanzamos el comando ls (list) seguido de los argumentos l (listado en detalle) y a (ver ficheros y directorios ocultos).
Además de este submódulo, también podemos ver Popen, el cual nos permite ejecutar órdenes igual que call y, además, controlar las salidas de dicho comando.
Popen, al igual que call, recibirá como primer argumento, una lista de uno o dos elementos donde el primero será el comando y el segundo los argumentos de dicho comando pero, a diferencia de call, con popen debemos cerrar el proceso manualmente. Un ejemplo sería:
1 2 3 |
from subprocess import Popen process = Popen(['ls', '-la']) process.wait() |
Como vemos en el ejemplo, creamos el objeto Popen para lanzar nuestro comando y después, llamamos al método wait(), el cual espera a que el proceso finalice para mostrar la salida.
Con Popen podemos capturar diferentes entradas y salida:
- Stdout: será la encargada de almacenar la salida de un programa
- Stdin: encarada de enviar información a un programa
- Stderr: mostrar los errores producidos en la salida de un programa
Para obtener esta captura, se pasan los elementos anteriores como argumentos clave a Popen. El valor de estos argumentos deberá ser un fichero o tubería que funcione como tal y para ello, Popen nos provee de una tubería para capturar dichas entradas y salidas llamada PIPE. Podemos ver un ejemplo:
1 2 3 4 5 6 7 8 9 10 |
from subprocess import PIPE, Popen proceso = Popen(['ls', '-la'], stdout=PIPE, stderr=PIPE) error = proceso.stderr.read() lista = proceso.stdout.read() proceso.stderr.close() proceso.stdout.close() if not error: print(lista) else: print("Se produjo el error: \n%s" % error) |
Como podemos observar, utilizamos el submódulo PIPE para capturar la salida del comando y del error, en caso de que diera, por el cuál no habría funcionado. No debemos olvidarnos de cerrar el proceso de captura con el método close(). Además, una vez capturado el error, podemos controlarlo para tratarlo de la forma que necesitemos en cada ocasión.
Al igual que en el resto de módulos mencionados anteriormente, podemos consultar más información acerca del módulo subprocess visitando la documentación oficial.
Hasta aquí el curso de python, gracias a todos por leernos y ya saben si tienen cualquier duda, les ayudaremos en aquello que podamos ‘legalmente’. Expongan sus comentarios y nos vemos en el próximo.
Además tenéis la lista completa de ejercicios y ejemplos en nuestro repositorio en github.
<- Anterior | Volver al índice |