Diferencia entre revisiones de «PrInf04: Comunicación con el usuario»

Revisión actual del 00:11 4 jul 2013

Los programas que vamos a escribir necesitarán en la mayoría de ocasiones interactuar con el usuario, ya sea mostrándole información, ya sea pidiéndole información para realizar los cálculos. En esta práctica vamos a ver cómo escribir mensajes en la pantalla (desde mensajes sencillos con el contenido de una variable, hasta mensajes más complicados con formato) y cómo recoger información proporcionada por el usuario a través del teclado.

1 Vídeos previos

Antes de realizar esta práctica, es recomendable ver estos vídeos del Curso de Introducción a la Programación. No es imprescindible verlos antes de hacer la práctica, pero sí recomendable. Si no has podido verlos antes, empieza la práctica, y vuelve a los vídeos después de la práctica.

• Prog06: Cómo comunicarnos con el usuario
• Prog07: Pedir información al usuario

También es recomendable haber realizado antes la práctica 1, en particular la parte de creación y manipulación de variables.

2 Comandos que se aprenderán en esta práctica

En esta práctica vamos a ver qué significan los siguientes comandos de MATLAB / Octave

3 Contenido de la práctica

3.1 Mostrar el contenido de variables

La manera más sencilla de mostrar el contenido de una variable es simplemente no incluir el punto y coma al final de una asignación o de una línea de código, y dejar que se muestre el resultado. Esta técnica puede ser útil cuando estamos desarrollando un programa, para ver resultados intermedios, y ayudar en la depuración del programa. Pero cuando tenemos el programa terminado, deberíamos cuidar los mensajes que se muestran en pantalla, y no mostrar detalles internos innecesarios al usuario. Para estas situaciones, es mejor usar los comandos disp y fprintf.

1. Vamos a ver un ejemplo sencillo. Crea una variable de nombre a que tenga de valor 2.7, sin olvidar el punto y coma final. Muestra su contenido con

   disp(a)

   El comando disp muestra en la pantalla el contenido de la variable.
2. El comando disp interacciona directamente con la pantalla. Lo que se muestra no es el resultado de una operación, sino que es el comando disp interactuando directamente con el dispositivo de salida, es decir, la pantalla. Para comprender este punto vamos a ejecutar el siguiente comando (fíjate en el punto y coma final)

   disp(a);

   ¿Por qué se muestra el resultado si hemos incluido el punto y coma al final? ¿Cuál es el cometido del punto y coma? En general, la mejor estrategia es siempre poner el punto y coma final en todos los comandos. Solo deberíamos quitarlo para mostrar resultados intermedios cuando estemos realizando pruebas. En cambio, si queremos mostrar al usuario la salida de un programa, hay que usar los comandos adecuados según el mensaje
3. Se pueden mostrar los resultados de variables de muy diversos tipos (textos, matrices, etc). Crea una matriz B aleatoria de orden 5, con números entre el 7 y el 16, sin que ningún elemento tenga parte decimal. No te olvides del punto y coma final. Ahora ejecuta

   disp(B);

   En general, disp mostrará correctamente cualquier variable de cualquier tipo.
4. Otro tipo de datos que se puede mostrar con disp es texto. En un lenguaje de programación se conoce como cadena de texto al conjunto de caracteres que forman un texto. Por ejemplo Hola caracola es una cadena de texto, formada por los caracteres H, o, etc. El término cadena proviene de la Teoría de Autómates y de Lenguajes de Programación, y ha sido heredada en la implementación y diseño de lenguajes de programación. Históricamente, este tipo de información tenía un tratamiento especial en los lenguajes, aunque los lenguajes modernos (como el lenguaje M) permiten manipular texto de manera sencilla. Veamos un ejemplo con disp

   t = 'Hola mundo'; disp(t);

   En Octave UPM, las cadenas de texto se delimitan usando comillas simples. En el ejemplo mostrado se asigna una cadena de texto a la variable t, que se muestra a continuación en la pantalla. La línea de código anterior ilustra otra de las ventajas de terminar los comandos con punto y coma. Como Octave UPM ya sabe que el comando anterior ha terminado, entiende que lo que viene a continuación es un nuevo comando. Hay que destacar también que disp muestra el contenido de la variable. Es decir, no vemos las comillas porque no forman parte del contenido de la variable. Las comillas solo sirven para que le indiquemos a Octave UPM que lo que incluimos entre ellas es un texto.
5. En todos los ejemplos anteriores hemos asignado un resultado a una variable y luego hemos mostrado la variable. Nada nos impide mostrar el resultado directamente. Por ejemplo

   disp('Hola mundo');

   En este caso, el resultado es el mismo que en el punto anterior, pero no hemos usado una variable intermedia.
6. También podemos poner el resultado de cualquier operación matemática. Por ejemplo,

   disp(4^3);

   ¿Qué muestra el comando en este caso? ¿Se ha asignado el resultado a la variable ans? ¿Podrías explicar por qué?

3.2 Mostrar mensajes formateados

El comando disp se limita a mostrar el contenido de una única variable. Si queremos combinar varias variables y texto en el mismo mensaje, es necesario usar un comando más complejo, pero también más versátil. Este comando es fprintf. En este comando, además de las variables que queremos mostrar, hay que indicar unos modificadores de formato, donde le decimos cómo mostrar el contenido de una variable.

1. El primer modificador que vamos a ver es el que nos permite mostrar números enteros. El modificador es %d. Veamos un ejemplo:

   a = 42; fprintf('El valor es %d', a);

   ¿Qué salida produce este comando?
2. Como habrás comprobado, el prompt de Octave UPM aparece ahora justo a continuación del mensaje, no en la siguiente línea. Éste es un comportamiento algo tonto del comando fprintf. Como nos permite modificar el formato totalmente, no asume nada acerca del mensaje; ni siquiera que tiene que saltar a la siguiente línea de texto tras mostrar el mensaje. Para saltar una línea podemos usar el caracter especial '\n'. Por ejemplo,

   fprintf('El valor es %d\n',a);

   ¿Cuál es el resultado ahora? ¿Cuál es la diferencia con la salida en el caso anterior?
3. El salto de línea puede ponerse en cualquier lugar del mensaje. Por ejemplo:

   fprintf('El\nvalor\nes %d\n',a);

   ¿Qué resultado produce este comando? Comprueba dónde están los saltos de línea en el mensaje, y cómo ha saltado de línea en cada sitio al mostrar el mensaje. El caracter '\n' no es un modificador de formato, sino que es un tipo de caracter especial, ya que no imprime nada visible en la pantalla. Pero Octave UPM lo trata internamente como cualquier otro caracter (como 'a','b','c', etc).
4. El modificador %d se puede usar con cualquier valor numérico. Nosotros lo hemos usado con valores sin decimales, pero también podemos intentar el siguiente comando

   a = 42.75; fprintf('El valor es %d\n', a);

   ¿Cuál es el resultado del comando anterior? ¿Ha cambiado el valor de a? ¿Por qué?
5. Para mostrar números con decimales podemos usar el modificador %f. Por ejemplo,

   fprintf('El valor es %f\n', a);

   ¿Cuántos decimales se muestran en el resultado?
6. Podemos controlar el número de decimales que se muestran. Por ejemplo, si queremos solo tres decimales en la pantalla:

   fprintf('El valor es %.3f\n', a);

   Es importante entender que el número de decimales que se muestran en la pantalla no tiene nada que ver con el número de decimales que contiene la variable representada. ¿Qué ocurre si le pedimos que solo muestre un decimal?
7. La potencia de fprintf radica en la capacidad de crear mensajes complejos. Por ejemplo, usando más de una variable en el mismo mensaje. Veamos un ejemplo:

   c = 7; v = 7.90; fprintf('La velocidad del coche %d es %.3f m/s\n', c, v);

8. También podemos combinar texto que estuviera dentro de una variable. Para mostrar texto tenemos que usar el modificador %s. Por ejemplo:

   c = 'Ford'; v = 7.90; fprintf('La velocidad del coche %s es %.3f m/s\n', c, v);

3.3 Pedir información al usuario

El comando para pedir información al usuario es input, que nos permite pedir cualquier tipo de dato (números, vectores, matrices, texto) y asignarlo a una variable.

1. El comando input por defecto puede recibir cualquier tipo de información. Por ejemplo, escribe 42 cuando el siguiente comando te pida el dato;

   x = input('Dame un numero: ');

   Comprueba el valor de x tras ejecutar el comando.
2. Ejecuta el mismo comando, pero responde ahora 1:5. Ejecútalo otra vez, y responde rand(5). ¿Cuál es el resultado? ¿Por qué?
3. Igual que hemos introducido vectores y matrices, podemos intentar introducir texto. Por ejemplo, vamos a pedir tu nombre. Introduce tu nombre cuando te lo pida el comando:

   n = input('Introduce tu nombre: ');

   ¿Ha fallado el comando? ¿Por qué?
4. Si no introducimos el valor tal y como lo asignaríamos a una variable, es probable que el comando falle. En particular, para introducir texto, tenemos que usar las comillas simples para delimitar el texto. Esto es algo engorroso. Ningún programa pide al usuario que conozca los detalles sobre cómo se representa la información en el lenguaje en el que está programado. Imagina que Facebook te pidiera usar comillas simples para escribir tu nombre. Para evitar las comillas al introducir texto, usamos un nuevo argumento en input

   n = input('Introduce tu nombre: ', 's');

   ¿Falla ahora al introducir tu nombre? ¿Cómo lo has introducido?
5. El comando input solo tiene este argumento especial para el caso del texto. Todos los demás tipos de datos tienen que introducirse siempre tal y como se asignarían a una variable. También podemos poner cualquier expresión cuando el comando nos pide introducir algo, y el resultado se asignará a la variable.

4 Ejercicio post-práctica

Queremos explorar el comportamiento de input con la introducción de texto. Para ello hemos realizado las siguientes pruebas. Los números de línea a la izquierda se incluyen solo como referencia, y no forman parte del código en sí. El código muestra una sesión de Octave UPM, por eso incluye el prompt (>>) al principio de algunas líneas. No hay que escribir el prompt para probar estos comandos en nuestra sesión.

>> n = input('Introduce tu nombre: ');
Introduce tu nombre: Israel
error: 'Israel' undefined near line 2 column 1
>> n = input('Introduce tu nombre: ');
Introduce tu nombre: 'Israel'
>> disp(n);
Israel
>> n = input('Introduce tu nombre: ', 's');
Introduce tu nombre: Israel
>> disp(n);
Israel
>> n = input('Introduce tu nombre: ', 's');
Introduce tu nombre: 'Israel'
>> disp(n);
'Israel'
>> n = input('Introduce tu nombre: ', 's');
Introduce tu nombre: '''Israel'''
>> disp(n);
'''Israel'''
>> n = input('Introduce tu nombre: ');
Introduce tu nombre: '''Israel'''
>> disp(n);
'Israel'

¿Podrías explicar por qué aparecen los resultados mostrados en las líneas 3, 7, 11, 15, 19 y 23?