Escribir programas ejecutables en Python. La línea de comandos.

Hasta ahora hemos hecho todos nuestros experimentos usando directamente IDLE, el entorno de programación propio de Python. Hemos visto una serie de conceptos básicos para comenzar a entender el lenguaje, y ya estaríamos en condición de escribir nuestros propios programas, es decir: más allá de probar sentencias en IDLE, escribir los programas en un fichero para ejecutarlos directamente desde el sistema operativo.

En esta entrada vamos a ver dos cosas: cómo se escribe un programa en Python de una forma que luego sea posible usarla, y por otro lado, una de las muchas formas en las que nuestros programas pueden recibir datos con los que trabajar y con la que realmente ya estamos familiarizados gracias al artículo sobre el terminal: la línea de comandos. De paso, entraremos en contacto con la inclusión de funcionalidad ya existente en nuestros programas: las librerías y cómo incluirlas.

Lo primero que vamos a hacer es crear un directorio dentro de la carpeta del usuario pi, si trabajas en la Raspberry, o en el lugar de tu elección si trabajas en Windows, en otro ordenador con Linux, o en el Mac, para guardar los ejercicios que hagamos a partir de ahora. Recuerda que si lo haces desde el terminal, la orden que debes usar para crear el directorio, por ejemplo, pitando, es la siguiente:

mkdir pitando

Escribir programas en Python ejecutables desde el sistema

Para este apartado nos sobra y nos basta con una variante mejorada del programa original con el que empezamos a movernos en Python: 

print("Hola, mundo")

Lo que vamos a hacer con él es que acepte variables: haremos que use dentro del saludo un nombre de persona que leerá de una variable. Así:

print("Hola, ", usuario)

Puedes probarlo en IDLE para ver que el resultado es el esperado: si asignas un valor a la variable usuario y lo ejecutas, deberías ver lo siguiente:

Captura 20150702 - 1

Es hora de guardarlo en el disco duro, hacerlo ejecutable y probarlo, primero en la Raspberry Pi, es decir, en Linux, y en el Mac (el proceso es exactamente igual para estas 3 plataformas). Luego haremos lo mismo en Windows, ya que el proceso es ligeramente distinto.

Abre el editor de texto de IDLE yendo al menú “File”, y haciendo click en la opción “New File”. Se abrirá una ventana en blanco en la que podremos escribir un programa completo disfrutando del coloreado del lenguaje y de los tabuladores automáticos igual que en la propia ventana interactiva de IDLE:

Captura de pantalla 2015-07-05 20.49.34

También puedes abrir esta misma ventana de editor con Control + N en tu Raspberry Pi, en Linux y en Windows, o con Comando + N en Mac. Comando es la tecla en la que pone cmd y el símbolo .

Escribe el siguiente contenido en el editor de textos que acabas de abrir:

#!/usr/bin/python3

usuario = "lector de PItando"
print("Hola, ", usuario)

exit(0)

En este listado hay 2 líneas que no conocemos, veámoslas una por una:

#!/usr/bin/python3

Esta línea no es Python, es una línea estándar del Terminal de Linux. Indica que el terminal tendrá que invocar al intérprete de Python para poder interpretar todo lo que sigue. En detalle:

  • # es un caracter que marca el comienzo de un comentario en programas de Terminal. Se llama “marca de comentario”. Casualmente, también en Python, pero insisto que esta línea pertenece y va a ser interpretada por el mismo terminal que vimos en su momento.
  • ! es un símbolo que, si es el estrictamente siguiente a la marca de comentario en el Terminal (sin espacios de por medio), y está en la primera línea del fichero, indica al intérprete del Terminal que debe delegar la interpretación del resto del fichero a un comando que se especifica justo a continuación.
  • /usr/bin/python3 es la ruta en donde está el intérprete de Python 3 en la Raspberry Pi. En el Mac está en una ubicación totalmente diferente, que es /Library/Frameworks/Python.framework/Versions/3.4/bin/python3

A partir de esa línea, y hasta el final del fichero, ahora sí todo es Python: el mismo código, además, que hemos estado probando en la ventana interactiva de IDLE.

Un pequeño truco antes de seguir: en cualquier Unix puedes obtener la ruta donde está instalado un programa con la orden which:

which python3

En Mac OS X daría como resultado /Library/Frameworks/Python.framework/Versions/3.4/bin/python3, mientras que en Linux (por ejemplo, en la Raspberry Pi) daría /usr/bin/python3.

La última línea también merece una mención especial:

exit(0)

Esta línea es una llamada a una función de Python, como print(), pero de un tipo especial: es una de las conocidas como “llamadas al sistema”. Las llamadas al sistema son una clase de funciones que se ocupan de comunicar tu código, en cualquier lenguaje, con el sistema operativo, tanto para pedir cosas como para proporcionarlas. En este caso, esta función realiza dos cosas:

  • Termina con la ejecución del programa. Cualquier línea de código Python tras ella, jamás será ejecutada.
  • Comunica que ha terminado con éxito, mediante el paso del número 0. El 0 aquí es un código que indica que no ha habido error.

¿Para qué sirve comunicar el resultado de la ejecución al sistema, si nuestra tarea ya ha terminado? Porque una de las gracias que tiene esto de programar es que un programa puede formar parte de otro más grande, y así sucesivamente, todo lo que queramos. Si no comunicamos un resultado, el programa que nos llame no podrá reaccionar ante lo que hayamos podido hacer.

Una vez visto todo esto, toca guardar el programa y ejecutarlo: entra en el menú “File”, opción “Save As…”. Aparecerá una ventana titulada “Guardar como” (sí, en español: este es el encanto que tienen las traducciones parciales), que espera que indiques la carpeta donde quieres guardar el programa, y el nombre que quieres darle. Las ventanas que esperan una respuesta por tu parte para continuar con un proceso puntual, como éste que consiste en guardar el fichero con un nombre, se llaman “cuadros de diálogo” (porque es un diálogo entre el programa y tú). En principio aparece en la carpeta principal del usuario pi:

Captura de pantalla 2015-07-05 20.55.02

Entraremos en la carpeta creada al principio del artículo (pitando), y daremos un nombre al fichero, como podría ser ejemplo.py. Pulsa intro para terminar, o haz click en el botón “Guardar”.

Ahora abre un Terminal y, usando tus conocimientos del artículo de uso del terminal, sitúate en el directorio recién creado, donde has guardado el programa que hemos escrito. Una vez allí, comprueba que existe el programa recién guardado y, después, escribe lo siguiente:

chmod +x ejemplo.py

Si ahora ejecutas el comando ls para examinar de nuevo el contenido del directorio, verás que el programa sale en color verde.

Captura 20150702 - 6

¿Qué ha ocurrido aquí? En Linux (y en cualquier Unix, como el Mac OS X), para poder ejecutar un programa hay que darle primero permisos de ejecución. Por seguridad, nada que escribas podrá ejecutarse hasta que se los des. Con chmod podremos actuar sobre permisos de lectura, escritura y ejecución. En el ejemplo hemos puesto +x: el signo + otorga permisos, y la letra x especifica el tipo “ejecución”. Si no especificamos nada más, los permisos otorgados o retirados afectarán al usuario actual. Consulta su página de manual como hemos aprendido la semana pasada para ver en detalle sus opciones. Recuerda que si no lo has hecho, ejecutar el comando siguiente en la consola descarga de internet la mayor cantidad posible de traducciones al español de las páginas del manual:

sudo apt-get install manpages-es

Ya sólo queda ejecutar el programa recién programado. Escribe lo siguiente:

./ejemplo.py

Verás que el programa ha funcionado porque nos saluda a través del Terminal, ya que en este caso es la salida estándar. La salida estándar viene a significar “el mismo medio por donde nos han llegado las órdenes”, ¿recuerdas? El resultado que deberías ver es el siguiente:

Captura 20150702 - 7

Sólo nos queda explicar por qué hay que ejecutar el programa poniendo delante ./. Linux, y todos los Unix (como el Mac OS X) sólo ejecutan programas de una serie de carpetas muy bien definidas, y ~/pitando no es una de ellas. Si queremos que el intérprete del terminal busque un programa en la carpeta donde estamos y no en otra, debemos especificarle la carpeta presente, que es justamente ./ como ya vimos la semana pasada. Si no, se iría a buscarlas a otras carpetas. ¿A cuáles? Escribe en el Terminal la siguiente orden:

echo $PATH

$PATH es una variable del itérprete del Terminal, más conocida como “variable de entorno”, que tiene una lista de directorios separados por dos puntos, “:”. echo es una orden del intérprete del Terminal que imprime valores de una forma muy parecida a print() en Python. Consulta su página de manual para saber más.

La línea de comandos

Es posible pasarle una serie de valores a un programa a través de la línea de comandos. Es decir, a través de la línea que escribimos en el terminal para poder hacer la llamada. Para eso hay que preparar el programa para recibir argumentos enviados desde el terminal, y procesarlos.

Primero, tenemos que importar una librería que nos ayude a recibir y procesar la línea de comandos, en este caso la librería sys. Abre el fichero ejemplo.py y, tras la línea #!/usr/bin/python3 escribe import sys. Quedará así:

#!/usr/bin/python3
import sys

Ahora comenta la línea usuario = "lector de PItando" añadiendo una almohadilla al principio, y añade usuario = sys.argv[1]. Debe quedar así:

#!/usr/bin/python3
import sys

# usuario = "lector de PItando"
usuario = sys.argv[1]
print("Hola, ", usuario)
 
exit(0)

Guárdalo con la opción “Save” del menú “File” y vuelve a ejecutarlo en la consola escribiendo esta vez lo siguiente:

./ejemplo.py Mortadelo

Verás que ahora el programa saluda a Mortadelo.

Captura 20150702 - 8

¡Estupendo!, ya sabemos enviar información a un programa desde el terminal, a la hora de invocarlo, igual que hacemos con todas las órdenes del sistema que vimos la semana pasada: id, mkdir, ls,… Esto da muchísima flexibilidad porque ya tenemos una pieza más para hacer programas realmente útiles; una pieza fundamental: la que nos permite enviar la información que queremos en cada caso.

Ya sólo nos queda explicar la línea usuario = sys.argv[1]. Al importar la librería sys hemos conseguido ciertas funcionalidades que nos permiten acceder a la línea de comando que hemos usado para llamar a nuestro programa. En la variable sys.argv, que es una lista, tenemos lo siguiente:

  1. En la primera posición, el nombre de nuestro programa; en este caso, ./ejemplo.py.
  2. En la segunda posición, tenemos el primer argumento.
  3. En la tercera, el segundo.

Y así sucesivamente. Las listas en Python empiezan a contar sus elementos desde 0, por eso para obtener el primer argumento (Mortadelo) hemos recogido el elemento número 1.

Ejercicio

Para reflexionar y aplicar los conceptos aprendidos hasta ahora, modifica el programa para que funcione de la siguiente forma:

  1. Si su primer argumento es “?” imprima un mensaje para ayudarnos a usarlo, en el que salga el nombre del programa ejecutable (para lo que tendrás que usar la variable sys.argv).
  2. Si no se especifica ningún argumento, debe saludar al lector (“Hola, lector“). Para detectar la longitud de una lista, usa la función len(lista).
  3. También haz que junte todos los argumentos en el mensaje de saludo. Para eso, ten en cuenta que en Python podemos juntar varias cadenas en una sola “sumándolas”:
cadena = "Hola" + ", Mundo"
# Cadena tendrá como valor "Hola, Mundo"

La semana que viene haré un artículo comentando la solución.

Vamos, por último, a ver cómo adaptar este programa a Windows

En Windows

Windows es algo completamente diferente a Unix, que es el sistema en el que se basa tanto el Linux de la Raspberry Pi (o cualquier otro) o muchos aspectos del Mac OS X. No queda otro remedio que dedicarle un tratamiento aparte siempre que nos queramos comunicar con el sistema operativo desde nuestros programas.

En este caso, ni la línea #!/usr/bin/python3 ni nada parecido funcionará en Windows. Podemos dejar dicha línea porque, al ser un comentario (# es la marca de comentario de Python), no molesta, pero en cualquier caso para ejecutar el programa deberemos primero escribir la ruta completa al ejecutable de Python. Entonces:

  • Guarda el código en un directorio de tu elección. Yo por ejemplo he creado una carpeta pitando dentro de la librería de Documentos, y he guardado el programa como ejemplo.py. Le he quitado la primera línea, como discutíamos antes.
  • Abre una consola de Windows, “ventana de MS-DOS” o “Ventana de línea de comandos” pulsando la tecla de Windows + R y escribiendo cmd:

Captura de pantalla 2015-07-05 15.54.09

  • Sitúate en la carpeta donde has guardado el programa. Si lo has guardado como yo bajo la librería de documentos de tu cuenta de usuario, escribe cd %userprofile%documentspitando; si es otra carpeta cualquiera, escribe cd y la ruta correspondiente (por ejemplo, si es c:progpitando, cd c:progpitando).
  • Ahora, recuerda dónde has instalado Python y localiza el programa python.exe, que es el intérprete de Python para Windows. Por ejemplo, yo lo he instalado en c:progPython34, y ahí es donde está el programa python.exe:

Captura de pantalla 2015-07-05 16.00.32

  • Vuelve a la ventana de línea de comandos y escribe la ruta completa hasta el programa python.exe y el nombre del programa (ejemplo.py), más el parámetro que sería el nombre a saludar. Pulsa intro:

Captura de pantalla 2015-07-05 16.02.09

No hace falta que me lo digáis: es un proceso muy farragoso, y por ejemplo no tenemos que darle permisos de ejecución al programa porque lo ejecutamos a través del propio intérprete.

Podemos hacerlo un poquito más cómodo incluyendo el directorio de instalación de Python en la variable de entorno PATH. Esta variable de entorno funciona igual que en Unix: tiene una lista de directorios donde el sistema operativo buscará programas ejecutables. Para hacerlo, haz click con el botón derecho en Mi PC (o “Este equipo”, dependiendo de tu versión de Windows) y selecciona “Propiedades”. Ve a “Configuración avanzada del sistema” y, en la pestaña “Opciones avanzadas” haz click en el botón “Variables de entorno”:

Captura de pantalla 2015-07-05 16.07.48

Captura de pantalla 2015-07-05 16.08.00

Pulsa en el botón “Nueva…” dentro de la sección “Variables de usuario para Gabriel” (en vez de Gabriel pondrá tu nombre) y, dentro del cuadro de diálogo que se te abrirá, escribe como nombre de la variable PATH (sin comillas) y como valor el directorio donde has instalado Python, un punto y coma, y después %PATH%.

Así:

Captura de pantalla 2015-07-05 16.08.28

Ahora pulsa en Aceptar en todas las ventanas que has abierto de las propiedades del PC (Mi PC / Este Equipo) y haz lo siguiente:

  • Cierra la ventana de línea de comandos / terminal de Windows / ventana de MS-DOS, y vuelve a abrirla (Windows + R, escribir cmd y pulsar intro).
  • Sitúate en el directorio donde has guardado el programa en Python (ejemplo.py)
  • Ejecútalo simplemente con python ejemplo.py Filemón

Captura de pantalla 2015-07-05 16.09.19

No es mucho, pero algo hemos ganado.

3 comentarios en “Escribir programas ejecutables en Python. La línea de comandos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *