Libreria Turtle
La libreria Turtle, son una serie de comandos completamente dedicados a una acción especifica.
Esta libreria puede crear una "Tortuga robot" que crea trazos dentro de un plano cartesiano determinado.
Esta tortuga comienza en el punto (0,0) del plano cartesiano y camina a travez de este plano dejando un rastro por donde pasa, lo cual puede ser muy util para graficar ciertos valores y funciones.
La tortuga tiene una cabeza, la cual apunta a una dirección (inicialmente hacia la derecha). Esta dirección se puede establecer y cambiar en grados de 0 a 360, o en radianes.
Tomemos por ejemplo el siguiente codigo:
>>import turtle #aqui importamos la libreria.
>>turtle.setup(800, 600) #aqui establecemos los parametros del plano cartesiano.
>>vent = turtle.Screen() #definimos vent al objeto de ventana
>>alex = turtle.Turtle() #definimos a nuestra tortuga robot, se llamará Alex.
>>alex.forward(300) #le decimos a Alex que camine hacia el frente 300px.
>>alex.left(90) #Le decimos que gire 90 grados hacia SU izquierda. (un cuarto de giro)
>>alex.forward(200) #Le decimos que avanze hacia el frente 200px.>>#Y como no tiene mas instrucciones, terminará de moverse en ese punto.
>>vent._root.mainloop() #Finalmente, este comando termina de ejecutar la ventana donde esta la tortuga.
Si todo sale bien, deberias ver una animación que haga el siguiente dibujo:
Una tortuga puede moverse por el plano con los siguientes comandos:
nombre.forward(d) : Avanza d pasos hacia la dirección donde mire tu tortuga.
nombre.backward(d) : Retrocede d pasos pasos hacia la dirección donde mire tu tortuga.
nombre.left (g): Gira a la izquierda g grados desde la dirección donde mire tu tortuga.
nombre.right (g) : Gira a la derecha g grados desde la dirección donde mire tu tortuga.
nombre.penup() :El trazo dejará de marcar el plano, no obstante podrás seguir moviendo la tortuga por este.
nombre.pendown(): El trazo volverá a marcar el plano si utilizaste el comando penup.
Una tortuga tambien se puede personalizar, con colores y formas, un ejemplo de esto puede ser:
>>import turtleAhora que establecimos el titulo, el color, el ancho y la forma de nuestra tortuga, se veria algo como esto:
>>turtle.setup(800, 600) # establecemos el tamaño de la ventana de 800 por 600 píxeles
>>vent= turtle.Screen() # establecemos vent al objeto de la ventana
>>spade= turtle.Turtle() #establecemos a nuestra tortuga.
>>vent.bgcolor("black”) # esto establece el color de fondo de la ventana, sea negro.
>>vent.title("Este es Spade”) # esto establece el título de la ventana.
>>spade.color("white”) # Esto hace que el color del trazo sea de color blanco.
>>spade.pensize(5) # establece el ancho del trazo.
>>spade.shape("turtle") #Esto establece la forma de nuestra tortuga, en este caso, resulta tener la forma de una tortuga real en lugar de una flecha.
>>spade.forward(300) #Empezemos a darle instrucciones. pidamos que haga un "8".
>>spade.left(120)
>>spade.forward(300)
>>spade.left(120)
>>spade.forward(600)
>>spade.right(120)
>>spade.forward(300)
>>spade.right(120)
>>spade.forward(300)
>>vent.exitonclick() #finalmente este es como el comando termina el codigo, pero a diferencia del anterior, lo hace cuando se da click en la pantalla.
Ahora empezaremos a combinar conocimientos de la clase anterior: Deberemos definir una función que tenga una tortuga que dibuje un poligono regular de n lados, y que cada lado mida un tamaño m:
>>import turtle
>>def polygon(n,m):
>>angulos = (360/n)
>>tamano = m
>>turtle.setup(800,600)
>>vent = turtle.Screen()
>>vent.bgcolor("lightblue")
>>vent.title("Polygon Maker")
>>poly = turtle.Turtle()
>>poly.shape("turtle")
>>poly.color("black")
>>poly.pensize(3)
>>while n>0:
>>poly.forward(tamano)
>>poly.left(angulos)
>>n=n-1
>>vent._root.mainloop()
Al ejecutar el codigo, lo siguiente que tendriamos que hacer es llamar a nuestra función en ventana.
Si lo hacemos, por ejemplo, con polygon(5,100), nos saldria esto:
Como desafio final para terminar con turtle, intentaremos dibujar un fractal. un fractal es un dibujo que tiene una estructura auto-similar, que és definida en términos de ella misma, es decir, que es Recursiva.
Para ser mas especifico, deberemos definir una función que grafique el Fractal curvo de koch en orden n, con una longitud m desde el punto inicial hasta el final.
>>import turtle
>>def koch(n,m):
>>kochy = turtle.Turtle()
>>vent = turtle.Screen()
>>vent.setup(800,200)
>>kochy.penup()
>>kochy.backward(m/2)
>>kochy.pendown()
>>def koch2(n,m):
>>if n==0:
>>kochy.forward(m)
>>else:
>>koch2(n-1,m/3)
>>kochy.left(60)
>>koch2(n-1,m/3)
>>kochy.right(120)
>>koch2(n-1,m/3)
>>kochy.left(60)
>>koch2(n-1,m/3)
>>koch2(n,m)
>>vent.exitonclick()
Explico basicamente lo que hice: Empezé a definir la función koch. definí la ventana y tortuga. Tambien le dije que iniciara el trazo m/2 pixeles mas atras del eje 0. Dentro de Koch empezé a definir otra función llamada koch2. En esta use un comando base (el primer if), e instrucciones recursivas del movimiento de la tortuga en el else. Termine de definir esa función, la llamo en la linea siguiente, pongo que termine de dibuja una vez haga click, y finalmente termino de definir la funcion inicial.
La razon por la cual definí una función mas pequeña dentro de la inicial, fue para que los parametros de mi tortuga no se repitieran una y otra vez a la hora de que la función se repitiera en sí misma. por lo cual las excluí, y los valores que si debian repetirse, los ejecute en una funcion propia.
y finalmente mi resultado fue el siguiente: koch(5,500)
Y poco mas se puede decir de la libreria Turtle, disfrute bastante esta materia en particular, y espero que lo hayan hecho tanto como a mi.
Me despido, C'YA~
