Una de las primeras cuestiones a aprender, en cuanto a programación estructurada es la
secuencia, o lo que es lo mismo, comprender que las instrucciones (sean las que sean) que se ponen unas detrás de las otras se ejecutan en el mismo orden en el que se escribieron. ¡Tan sencillo como esto!
Para comenzar, utilizaremos el módulo turtle. Este módulo permite manejar una tortuga por la pantalla, de tal manera que podemos hacer dibujos sencillos, ya que la tortuga deja rastro a medida que avanza. ¿Cuál va a ser el objetivo? Nada más y nada menos que hacer un dibujo de una escalera. ¿Fácil, verdad?
Para poder utilizar el módulo de la tortuga,
turtle, debemos indicarle a
jC que lo necesitaremos, y para eso se emplea la sentencia
import. El módulo de la tortuga necesita del módulo de funciones gráficas (
gw), así que será necesario importarlo también:
import gw;
import turtle;
De acuerdo, ahora sólo es necesario empezar a darle órdenes a la tortuga. Para comprobar qué funciones soporta, sólo es necesario pulsar F1 y hacer click en el módulo de la tortuga. Para hacer que la tortuga avance, es necesario emplear la función
forward(), y tenemos que pasarle la distancia a avanzar.
import gw;
import turtle;
turtle.forward( 25 );
¡Fantástico! La tortuga ha avanzado 25 pixels, con lo cuál ha visualizado una pequeña línea recta. Quizás te preguntes dónde está la tortuga. La tortuga en sí no se ve, aunque estaría al final de lo último que has dibujado. Los gráficos de tortuga tienen su origen en el lenguaje de programación
LOGO, que fue creado precisamente para enseñar a los principiantes a programar, con la ventaja de apreciar sus avances visualmente.
Hay una línea separando los imports de la llamada a forward() porque así queda más claro. Las líneas en blanco no son significativas, podríamos dejar veinte si quisiéramos. O ninguna. Pero es importante que el programa sea fácil de leer, incluso por ti mismo, cuando lo retomes dentro de un tiempo. Así que cuanto más claro esté el código (el código o el código fuente son las instrucciones del programa), mejor.
USamos la funciión
forward(), pero... ¿qué es una función? Si en un programa logramos que se realice una tarea poniendo una instrucción después de otra, una función es un conjunto de instrucciones que ha preparado alguien, con un nombre determinado, para lograr una tarea determinado. En concreto,
forward() es una secuencia de instrucciones que ha preparado servidor para que la gente no tenga que programar el comportamiento de la tortuga una y otra vez: sólo úsalo. Las veces que haga falta.
La primera instrucción que hemos utilizado ha sido
turtle.forward( 25 ). En realidad, habría sido igual de efectivo indicar exclusivamente
forward( 25 ). Estrictamente, la parte
turtle. sólo hace referencia al módulo donde está la función a continuación,
forward(). Como no hay ambigüedad, (no estamos utilizando una función que esté creada en otro módulo con el mismo nombre), no sería necesario, como decía, añadir el prefijo
turtle. Pero nos sirve como documentación, de forma que sabemos que es exactamente ese módulo el que queremos usar.
Hagamos algo más. Si giramos la tortuga noventa grados, conseguiremos que "apunte" hacia abajo, y entonces podremos avanzar otro poco, haciendo un escalón. Para girar, tenemos las funciones
turnRight() y
turnLeft() del módulo de la tortuga.
import media.gw;
import media.turtle;
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
De acuerdo, las instrucciones se ejecutan una detrás de la otra: avanzamos hacia la derecha (al principio, la tortuga apunta hacia la derecha por defecto), giramos noventa grados, avanzamos de nuevo... y con eso se ha dibujado un escalón en la pantalla.
Vamos por buen camino. Ahora sólo es necesario repetir lo de antes, para conseguir una escalera completa. De acuerdo, sólo será necesario copiar las instrucciones que ya tenemos ahora (menos los
imports) y pegarlas tres veces para conseguir una escalera de tres peldaños.
¡Vaya, pues no funciona! Si lo has probado, comprobarás que no sale una escalera. Tiene sentido, una vez que completamos un peldaño, debemos hacer que la tortuga mire hacia la derecha de nuevo. Es mejor borrarlo todo y volver a empezar. Partir del listado de más arriba. Hemos aprendido que copiar y pegar, sin pensar en lo que estamos haciendo, no es una buena idea.
Para colocar la tortuga apuntando hacia la derecha, debemos girarla noventa grados en sentido contrario hacia donde la giramos antes. Es decir, para tener dos escalones:
import media.gw;
import media.turtle;
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
turtle.turnLeft( 90 );
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
No queda muy claro lo que estamos haciendo. Es fácil perderse viendo el código fuente. Para clarificarlo, incorporaremos comentarios dentro del código, que nos digan lo que hace cada grupo de instrucciones. Pero claro, no podemos permitir que se compilen esos comentarios... ¡sería desastroso!. Si empezamos una línea con //, haremos que esa línea no se compile, pudiendo poner a continuación lo que queramos.
import media.gw;
import media.turtle;
// Escalón inicial
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
// Escalón siguiente
turtle.turnLeft( 90 );
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
De acuerdo, ahora sí. Si copiamos y pegamos las instrucciones desde el comentario de Escalón siguiente, hasta el final, podemos incorporar todos los peldaños que queramos, simplemente según el número de veces que peguemos. El código final es:
/** @name escalera
* @brief Dibuja una escalera en pantalla
* @author jbgarcia@uvigo.es
* @date 2013-06-28
*/
import media.gw;
import media.turtle;
// Escalón inicial
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
// Escalón siguiente
turtle.turnLeft( 90 );
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
// Escalón siguiente
turtle.turnLeft( 90 );
turtle.forward( 25 );
turtle.turnRight( 90 );
turtle.forward( 25 );
La primera parte es un comentario especial. Cuando empezamos un párrafo por /*, ese párrafo no se compila. Si se empieza por /**, entonces es que se trata de un comentario de documentación. Si pulsas F4 (una vez introducido y ejecutado el programa), verás la documentación generada a partir de ese comentario.
