e historia de la tableta Etch-a-Sketch
La tableta Etch-a-Sketch fue una de las creaciones de juguetes más interesantes de finales de los años cincuenta. El Etch-a-Sketch es básicamente una tableta parecida; el marco rojo tiene una pantalla incrustada y dos perillas. Estas perillas controlan los movimientos horizontales y verticales de un lápiz detrás de la pantalla. Este producto rápidamente se convirtió en un gran éxito, con más de 1 millón de unidades vendidas durante el primer año. Fue uno de los inventos que mantendría a los niños ocupados haciendo dibujos y divirtiéndose y, al mismo tiempo, promovería el desarrollo cognitivo al mejorar las habilidades motoras finas, la coordinación mano-ojo y la conciencia espacial a través de bocetos controlados por perillas. Se hizo tan popular que incluso apareció en películas como Toy Story.
Entendiendo el proyecto
En este artículo, utilizaremos el módulo Python Turtle para desarrollar nuestra versión digital de estilo propio de Etch-a-Sketch. Este es un tutorial de nivel principiante a intermedio, que requeriría una comprensión básica de los fundamentos de Python, como funciones, bucles, etc. de Python. A través de la codificación de este proyecto, aprenderemos el manejo de eventos, coordenadas y movimientos, funciones y bucles de Python, así como la retroalimentación visual consiguiente. Además, también comprenderemos el concepto de instancias en programación orientada a objetos. Esta es una implementación interesante del concepto central de Python y una forma divertida de aprender a programar a través de un proyecto visual. ¡Empecemos!
Módulo Turtle de Python para codificación visual
Para crear una aplicación Etch-a-Sketch, necesitaremos una representación visual de nuestro código. Aquí es donde entra en juego el módulo Turtle de Python. El módulo tortuga es parte de la biblioteca estándar de Python y permite dibujar en un sistema de coordenadas 2D mediante comandos simples. El módulo también admite entrada de teclado, comportándose como un lápiz digital y, por lo tanto, haciéndolo ideal para simular un Etch-a-Sketch.
El módulo tortuga se basa en una tortuga robótica, a la que se le dan algunos comandos que sigue y produce dibujos en consecuencia. Para usar esta funcionalidad, simplemente tenemos que importar el módulo a nuestro código y luego usar las funciones definidas, que se pueden explorar en la documentación oficial aquí.
Las siguientes son algunas líneas de código que importan el módulo y utilizan la función más útil para dibujar en la pantalla:
importar tortuga tortuga.adelante(100) tortuga.derecha(90) tortuga.adelante(100) tortuga.derecha(45) tortuga.adelante(100) tortuga.exitonclick()
La función de avance se utiliza para mover el cursor hacia adelante y toma la distancia como argumento, mientras que la función de derecha gira la cabeza de la tortuga hacia la derecha en el ángulo que se da como argumento. Se puede acceder a más detalles de cada función a través de la documentación oficial.
El módulo Turtle también tiene capacidades de programación orientada a objetos, lo que significa que podemos crear objetos a partir de un plano determinado. Las clases Turtle y Screen se pueden usar para crear instancias de objetos que se usarán en nuestro código. Creemos estos:
my_pen= Turtle() my_pen.width(3) my_pen.speed(0) screen = Screen() screen.title(“Grabar un boceto”)
Vea cómo creamos un objeto tortuga y lo llamamos my_pen de la clase Turtle que forma parte del módulo Python Turtle. También hemos creado el objeto pantalla, que nos permitirá visualizar el movimiento del lápiz así como personalizarlo según nuestras necesidades. También hemos personalizado el ancho y la velocidad del lápiz, además de nombrar la pantalla.
Definición de las funciones de movimiento
Lo siguiente es definir las funciones para el movimiento de nuestro bolígrafo. Al igual que la tableta física Etch-a-Sketch, que cuenta con 2 mandos, uno para el movimiento vertical de arriba y abajo, y el segundo para el movimiento horizontal de izquierda a derecha, definiremos un total de 4 funciones:
Mover hacia adelante: Esto moverá el lápiz hacia arriba, sinónimo del movimiento hacia arriba en la tableta original. Mover hacia atrás: Esto moverá el lápiz hacia abajo, sinónimo del movimiento hacia abajo en la tableta original. Girar a la izquierda: esto moverá el lápiz hacia la izquierda en un ángulo determinado. Girar a la derecha: Esto moverá el lápiz hacia la derecha en un cierto ángulo.
Codifiquemos lo anterior como funciones:
def move_forwards(): mi_pen.forward(50) def move_backwards(): my_pen.backward(50) def turn_left(): new_heading = my_pen.heading() + 10 my_pen.setheading(new_heading) def turn_rigth(): new_heading = my_pen.heading() – 10 my_pen.setheading(new_heading)
En las dos primeras funciones, hemos utilizado directamente las funciones de tortuga de avance y retroceso. En las funciones de movimiento horizontal, turn_left y turn_right, hemos definido una nueva variable new_heading que es básicamente el ángulo en el que girará el lápiz. El new_heading toma el rumbo del bolígrafo que es el ángulo actual y suma 10 grados en caso de girar a la izquierda y resta 10 grados en el caso de girar a la derecha. Este ángulo se almacenará como new_heading que actuará como argumento para la función setheading que establece la orientación del lápiz según el ángulo dado como argumento.
También definiremos una función que limpiará la pantalla. Esta función utiliza la función de limpieza de la tortuga que elimina el dibujo de la tortuga de la pantalla sin afectar el estado y la posición de la tortuga. También devolverá la posición del lápiz a inicio, utilizando las funciones penup, home y pendown:
def clear_screen(): mi_pluma.clear() mi_pluma.penup() mi_pluma.home() mi_pluma.pendown()
Escucha de pantalla
Una de las capacidades del módulo Turtle es que se adapta a eventos de escucha en pantalla. En programación, la escucha de eventos es un concepto que detecta y responde a las acciones del usuario. En nuestro caso la acción del usuario será a través del teclado, utilizando las teclas WASD para el movimiento del lápiz. Usaremos esta funcionalidad en nuestro código. Esto se puede lograr usando el método listening y onkey para el objeto de pantalla. El método de escucha se utiliza para recopilar eventos clave y el método onkey define la función que se llamará de acuerdo con la tecla particular que se ha presionado.
screen.listen() screen.onkey(move_forwards, “w”) screen.onkey(move_backwards, “s”) screen.onkey(turn_left, “a”) screen.onkey(turn_rigth, “d”) screen.onkey(clear_screen, “c”)
Por último, como queremos conservar la pantalla, usaremos el método de pantalla exitonclick que mantendrá la pantalla allí hasta que hagamos clic en ella.
pantalla.exitonclick()
¡Grabado y bocetos!
Ahora que nuestro código está completo, ejecutaremos el programa. Aparecerá una pantalla ante nosotros y permanecerá así hasta que hagamos clic en cualquier lugar de ella.
Usaremos las teclas “W”, “A”, “S” y “D” para crear un dibujo y “C” para limpiar la pantalla. ¡Dibujemos un círculo a través del teclado!
También puedes dibujar un círculo simplemente avanzando con “W” y luego girando la tecla izquierda “A” dos veces, y continuando así hasta que el lápiz alcance su posición inicial. También podemos practicar dibujando formas y entender la geometría mientras jugamos con este programa.
Mejorando el proyecto
Ahora que nuestro programa básico está creado, podemos agregar muchas otras características que personalizarían y mejorarían aún más nuestra creación, como por ejemplo:
Agregar teclas y funciones correspondientes para movimientos diagonales Cambiar el color del lápiz Guardar los dibujos y exportar el lienzo como imagen
Conclusión
Hemos utilizado con éxito nuestros conocimientos básicos de Python y el módulo Turtle para crear un programa digital Etch-a-Sketch. Esta es una forma divertida de aprender a programar y de comprender las coordenadas, ya que todo se muestra visualmente. También facilita señalar cualquier error que se cometa en el código y depurarlo de manera oportuna. Aunque su código es simple, este tipo de programa forma la base de programas y software gráficos complejos, por lo que una comprensión básica de la interfaz gráfica es crucial para comprender los fundamentos de los gráficos digitales.