Python permite obtener y mostrar información de formas diferentes. Para ello hace uso de los flujos de entrada y salida de datos. En este breve tutorial explicaré su funcionamiento.
Lectura de datos
Sabemos que Python nos permite utilizar ficheros para guardar información y procesar información, pero en ocasiones es necesario interaccionar con el usuario para preguntarle cierta información necesaria que que no pudo ser guardada en estos ficheros.
Para realizar este proceso Python dispone de la función input(), que nos permite solicitar al usuario información y poder utilizarla en nuestros scripts.
|
1 2 |
nombre = input("Dime tu nombre:") print("Hola, " + nombre) |
La función input() siempre nos devuelve un tipo de dato string, por lo que sí necesitamos que nos devuelva otro tipo de dato, necesitamos convertirlo. En el siguiente ejemplo le vamos a pedir al usuario un valor entero.
|
1 2 3 4 5 6 |
def cuadrado(): numero = int(input("Dime un número:")) cuadrado = numero**2 print("El cuadrado de {} es {}".format(numero, cuadrado)) cuadrado() |
Podemos modificar el script, para que este siga ejecutándose una y otra vez y de esta manera permitir al usuario seguir interaccionando con el script. El usuario podrá parar la ejecución del script cuando desee mientras se cumpla la condición establecida.
|
1 2 3 4 5 |
respuesta = "s" while (respuesta.lower() == "s"): cuadrado() respuesta = input("¿Deseas realizar otro cálculo? ") print("Hasta luego!") |
Los Flujos estándar
Cuando sabemos como escribir en ficheros y solicitar información al usuario, la pregunta que nos podemos hacer es, ¿Cómo hace Python para conectar pantalla y teclado?. La respuesta es, a través de los flujos de entrada y salida de datos. Estos flujos son los mecanismos que nos permiten realizar operaciones de entrada y salida en nuestros programas.
Teclado (entrada|input) → Programa → Pantalla (salida|output)
La mayoría de los Sistemas Operativos ofrecen tres flujos de entrada y salida de datos por defecto, cada uno de ellos para un propósito específico.
- Entrada de datos estándar (stdin), es un canal de comunicación entre el programa y la entrada de datos (normalmente en formato texto desde un teclado).
- Salida de datos estándar (stdout), es un canal de comunicación entre el programa y la salida de datos (normalmente en formato texto a través de una pantalla).
- Salida de Errores (stderr), es un canal de comunicación para mostrar errores y mensajes de diagnóstico de un programa (normalmente en formato texto a través de la pantalla).
Cuando usamos la función input() estamos usando el canal de comunicación de entrada de datos STDIN. La función print() es un claro ejemplo de un flujo de datos STDOUT. Si ejecutas un script escrito en Python y recibes un error, ese error probablemente es impreso usando el canal de comunicación STDERR.
Variables de entorno
Cuando ejecutamos una aplicación desde un terminal en un Sistema Operativo Linux, ya sea desde una máquina local o remota, la aplicación que se encarga de leer y ejecutar todos los comandos se llama Shell.
El Shell es una interfaz de línea de comandos, que nos permite interactuar con el Sistema Operativo. El Shell más usado actualmente en Linux es Bash (GNU Bash) y otros no menos importantes son zsh (Z Shell) o fish (Friendly interactive shell).
Los programas escritos en Python son ejecutados en entorno de línea de comandos Shell y todas las variables establecidas en ese entorno podrán ser utilizadas en nuestros scripts. Saber cómo cambiar estas variables, nos será útil para alterar el comportamiento de los programas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
$ env XDG_SESSION_ID=2947 TERM=xterm SHELL=/bin/bash SSH_CLIENT=xx.xxx.xx.xx 41024 22 SSH_TTY=/dev/pts/0 USER=xxxx MAIL=/var/mail/ejemplo.com PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games PWD=/var/www/vhosts/ejemplo.com LANG=en_US.UTF-8 SHLVL=1 HOME=/var/www/vhosts/ejemplo.com LOGNAME=ejemplo.com SSH_CONNECTION=xx.xx.xx.xx 41024 xx.xx.xx.xx 22 XDG_RUNTIME_DIR=/run/user/10002 _=/usr/bin/env |
La variable PATH es una variable de entorno muy importante. Podemos mostrar su contenido usando el comando echo (comando para imprimir texto en el Shell de Linux), seguido del nombre de la variable precedido del símbolo dólar.
|
1 2 |
$ echo $PATH /home/user/.local/bin:/home/user/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin |
El Shell usa la variable de entorno PATH para saber dónde buscar los ficheros ejecutables y así poder llamarlos desde el directorio donde nos encontremos. El contenido de todas estas variables, podemos leerlos desde nuestros scripts escritos en Python. Para ello podemos usar la función environ() del módulo OS de Python. Veamos un ejemplo desde el intérprete de Python.
|
1 2 3 4 5 6 |
>>> import os >>> print("Directorio de trabajo " + os.environ.get("HOME", "")) >>> print("Shell " + os.environ.get("SHELL", "")) Directorio de trabajo /home/jose Shell /bin/bash |
Si necesitamos definir una nueva variable de entorno desde línea de comandos, usamos el comando export.
|
1 |
$ export IVA=0.21 |
Argumentos de línea de comandos
Otra forma de incluir o aportar información a nuestros programas, es a través de argumentos de línea de comandos. Estos argumentos o parámetros se los pasaremos al programa una vez sea inicializado.
En Python, estos parámetros son guardados por el módulo sys y podemos acceder a sus valores usando argv. El primer argumento que nos devuelve es el nombre del script.
|
1 2 3 4 |
$ ./test.py 1 2 >>> import sys >>> print(sys.argv) ['./test.py', '1', '2'] |
Por último vamos a hablar del concepto exit status o también llamado código de retorno que aporta información entre el Shell y los programas que se ejecutan dentro de él. En todos los Sistemas Operativos Unix si obtenemos 0 (cero) como valor de retorno, sabremos que el proceso ha tenido éxito.
Por lo que este valor de retorno nos servirá para saber si nuestros programas se han ejecutado correctamente o usar esta misma información para volver a ejecutar el programa en caso de que este falle.
Para poder comprobar este valor usamos el signo de interrogación y para ver su contenido usaremos el signo del dólar seguido del signo de interrogación. Mejor verlo con un ejemplo usando el comando wc que devuelve el número de líneas, palabras y caracteres de un fichero. Primero le pasaremos las variables a nuestro script y comprobaremos el valor de retorno.
|
1 2 3 4 |
$ wc ./test.py 3 6 51 ./test.py $ echo $? 0 |
Ahora veamos otro ejemplo cuando el programa es ejecutado y devuelve un código de error, debido a que el fichero no existe.
|
1 2 3 4 |
$ wc ./programa.py wc: ./programa.py: No such file or directory $ echo $? 1 |
Ahora que sabemos cómo funcionan los valores de retorno en línea de comandos, ¿Cómo comprobamos estos valores usando Python?. Veamos un ejemplo donde pasamos un nombre de fichero a nuestro programa, este lo crea sino existe o devuelve un error en caso contrario.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#! /usr/bin/env python3 import os import sys fichero = sys.argv[1] if not os.path.exists(fichero): with open(fichero, "w") as f: f.write("Fichero creado\n.") else: print("Error, el fichero {} ya existe ".format(fichero)) sys.exit(1) |
Ahora comprobemos cuál es el resultado en ambos casos.
|
1 2 3 4 5 6 7 |
$ ./crear_fichero.py LEEME.md $ echo $? 0 $ ./test.py LEEME.md Error, el fichero LEEME3.md ya existe $ echo $? 1 |
