🖍️
Juguemos con python
  • Juguemos con python🐍
  • ¿Qué es un algoritmo?
  • Estructuremos el algoritmo
  • ¿Qué es programar? 👩🏻‍💻
  • Pseudocodigo
  • Variables
  • Tortuguita
    • 🐢Turtle
  • 🏡Casita
  • Turtle en Google Colab
Powered by GitBook
On this page

Was this helpful?

🏡Casita

¡Ahora manos a la obra ! Vamos a aplicar los conceptos que hemos aprendido y dibujaremos una casita con la ayuda de python.

Previous🐢TurtleNextTurtle en Google Colab

Last updated 3 years ago

Was this helpful?

Para empezar debes dirigirte a , que es una plataforma donde programaremos y construiremos nuestra casita. Allí debes crear una cuenta con tu correo electrónico.

Ya que estamos en la plataforma...

El primer paso es importar las librerías que nos brindarán las herramientas para construir nuestra casita Estas son (pizarra y gráficos) y (funciones matemáticas).

¿Pero qué es una librería? Una librería es un conjunto de funciones y métodos a los que puedes acceder para facilitar tu programación.

#importamos las librerias
import turtle
import math

El segundo paso es crear nuestra pantalla y darle color, Turtle es una librería gráfica, lo que significa que debemos crear una ventana separada (llamada pantalla ), para ejecutar cada comando de dibujo.

Para crear nuestra pantalla debemos seguir los siguientes pasos:

  • Crear una variable para definir la pantalla, el nombre de esta variable es screen.

  • Darle color azul a nuestra pantalla.

¿Pero qué es una variable? Python usa variables para almacenar información que usará más adelante en el programa. Se inicializa o se define una variable cuando se le asigna un valor inicial. Como el valor de la variable no es constante, puede cambiar varias veces durante la ejecución del programa.

# Creamos la variable screen para definir la pantalla
screen = turtle.Screen()
# Le damos color azul a nuestra pantalla
screen.bgcolor("skyblue")

El cuarto paso es crear nuestra tortuga y modificar sus características, la tortuga es el lápiz con el cuál dibujaremos en nuestra pantalla. La tortuga tiene ciertas características cambiantes, como tamaño, color y velocidad. Debemos seguir los siguientes pasos:

  • Definir o inicializar la variable tortuguita, que luego utilizaremos para referirnos al lápiz con el cual dibujaremos.

  • Darle color negro a nuestra tortuguita.

  • Darle forma de tortuga. Otras formas que le podemos dar a nuestro lápiz son: “arrow”, “circle”, “square”, “triangle”, “classic”.

  • Configurar la velocidad de nuestra tortuguita, esta está representada por un número de 0 a 10. Como queremos una tortuguita súper rápida, su velocidad será de 10.

# Definimos o inicializamos  la variable tortuguita
tortuguita = turtle.Turtle()
# Damos color negro a nuestra tortuguita
tortuguita.color("black")
# Damos forma de tortuga a nuestra tortuguita
tortuguita.shape("turtle")
# Damos super velocidad a nuestra tortuguita
tortuguita.speed(10)

La pantalla que creamos anteriormente actúa como un lienzo, mientras que la tortuga actúa como un lápiz. Podemos programar la tortuga para que se mueva por la pantalla y cree figuritas.

El quinto paso es crear una función que dibuje y coloree un rectángulo

¿Pero qué es una función? Una función es un bloque de código que se encarga de realizar una determinada tarea. Para declarar una función solo se debe poner la palabra "def" seguido del nombre de la función y los parámetros o información que necesita la función para realizar la tarea. Por último debes poner las instrucciones que quieres que realice la función.

El nombre de la función será drawRectangle y la información que nuestra función necesita para realizar su tarea es: ¿qué tortuguita o lápiz va a usar la función para dibujar la casita (t)?, ¿qué ancho tendrá tu casita (width)?, ¿qué largo tendrá tu casita (height)? y ¿qué color tendrá tu casita (color)? .

Ahora debemos definir las instrucciones que llevará a cabo nuestra función, para esto vamos a usar los siguientes métodos de la librería turtle:

  • .fillcolor(color): Configura el color de la figura.

  • .begin_fill(): le indica a la tortuguita que va a empezar a colorear una figura.

  • .forward(unidades): le indica a la tortuguita que debe moverse tantos pasos o unidades hacia delante.

  • .left(grados): le dice a la tortuguita que debe voltearse tantos grados hacia la izquierda.

  • .end_fill(): le indica a la tortuguita que debe terminar de colorear.

# Define una funcion que dibuja y colorea un rectángulo
def drawRectangle(t, width, height, color):
  t.fillcolor(color)
  t.begin_fill()
  t.forward(width)
  t.left(90)
  t.forward(height)
  t.left(90)
  t.forward(width)
  t.left(90)
  t.forward(height)
  t.left(90)
  t.end_fill()

El sexto paso es definir una función que dibuje y coloree un triangulo, que será el techo de nuestra casita.

El nombre de la función será drawTriangle y la información que nuestra función necesita para realizar su tarea es: ¿qué tortuguita o lápiz va a usar la función para dibujar el techo (t)?, ¿qué longitud va a tener la hipotenusa del triangulo?, y ¿qué color (color) tendrá tu techo? .

¿Pero qué es una hipotenusa? El lado mas largo de un triangulo rectánculo.

Ahora debemos definir las instrucciones que llevará a cabo nuestra función, para esto vamos a usar los mismos métodos de la función que creamos anteriormente:

# Define una funcion que dibuja y colorea un triangulo
# equilatero 
def drawTriangle(t, length, color):
  t.fillcolor(color)
  t.begin_fill()
  t.forward(length)
  t.left(135)
  t.forward(length / math.sqrt(2))
  t.left(90)
  t.forward(length / math.sqrt(2))
  t.left(135)
  t.end_fill()

El séptimo paso es definir una función que dibuje y coloree un paralelogramo, que será un lado de nuestra casita.

El nombre de la función será drawParallelogram y la información que nuestra función necesita para realizar su tarea es: ¿qué tortuguita o lápiz va a usar la función para dibujar el lado de la casita (t)?, ¿qué ancho tendrá le lado de la casita?, y ¿qué color tendrá (color) ? .

# Define una función que dibuja y colorea un 
# paralelogramo
def drawParallelogram(t, width, height, color):
  t.fillcolor(color)
  t.begin_fill()
  t.left(30)
  t.forward(width)
  t.left(60)
  t.forward(height)
  t.left(120)
  t.forward(width)
  t.left(60)
  t.forward(height)
  t.left(90)
  t.end_fill()

El octavo paso es definir una función que dibuje cuatro rayos de sol.

El nombre de la función será drawFourRays y la información que nuestra función necesita para realizar su tarea es: ¿qué tortuguita o lápiz va a usar la función para dibujar los rayitos (t)?, ¿qué longitud tendrán los rayitos?, y ¿de qué color radio es el sol que dibujaremos ?

Ahora debemos definir las instrucciones que llevará a cabo nuestra función, para esto vamos a usar un ciclo for, para repetir los mismos pasos para cada rayito.

Usaremos las funciones pendown() y penup() son equivalentes a bajar y levantar el lápiz del papel. Una vez levantado el lápiz del papel, al desplazar el lápiz ya no se dibujan segmentos. Al volver a bajar el lápiz, al desplazar el lápiz vuelven a dibujarse los fragmentos.

También usaremos el método backward(unidades), se utiliza para mover la tortuga hacia atrás, el número de unidades que definamos.

# Define a function to draw four sun rays of the given length,
# for the sun of the given radius.  The turtle starts in the 
# center of the circle.
def drawFourRays(t, length, radius):
  for i in range(4):
    t.penup()
    t.forward(radius)
    t.pendown()
    t.forward(length)
    t.penup()
    t.backward(length + radius)
    t.left(90)

Por ejemplo, en el siguiente fragmento de código vamos dibujar el frente de la casa. Para eso vamos a seguir los siguientes pasos:

  • Vamos a levantar el lápiz del tablero para no trazar segmentos, esto mientras nos ubicamos en la zona del tablero donde vamos a dibujar.

  • Luego vamos a ubicarnos en la zona del tablero donde vamos a dibujar( -150 unidades en el eje x) (-120 unidades en el eje y).

  • Ya ubicados, bajamos el lápiz para empezar a dibujar.

  • Luego, podemos usar nuestra función drawRectangle, para dibujar un rectángulo azúl, usando la variable tortuguita (lápiz) que creamos en el cuarto paso, el ancho del rectángulo será de 100 unidades y el largo será de 110.

# levantamos el lápiz del tablero para no trazar 
# segmentos
tortuguita.penup() 
# nos ubicamos en la zona del tablero donde 
# vamos a dibujar
tortuguita.goto(-150, -120)
#  bajamos el lápiz para empezar a dibujar
tortuguita.pendown()
# dibujamos el rectángulo
drawRectangle(tortuguita, 100, 110, "blue")

Como en el ejemplo anterior, empezaremos a usar las funciones que construimos anteriormente, para dibujar los elementos de la casita.

# Dibujar y colorear la puerta
tortuguita.penup()
tortuguita.goto(-120, -120)
tortuguita.pendown()
drawRectangle(tortuguita, 40, 60, "lightgreen")

# El techo
tortuguita.penup()
tortuguita.goto(-150, -10)
tortuguita.pendown()
drawTriangle(tortuguita, 100, "magenta")

# El lado de la casa
tortuguita.penup()
tortuguita.goto(-50, -120)
tortuguita.pendown()
drawParallelogram(tortuguita, 60, 110, "yellow")

# la ventana
tortuguita.penup()
tortuguita.goto(-30, -60)
tortuguita.pendown()
drawParallelogram(tortuguita, 20, 30, "brown")

# El lado del techo
tortuguita.penup()
tortuguita.goto(-50, -10)
tortuguita.pendown()
tortuguita.fillcolor("orange")
tortuguita.begin_fill()
tortuguita.left(30)
tortuguita.forward(60)
tortuguita.left(105)
tortuguita.forward(100 / math.sqrt(2))
tortuguita.left(75)
tortuguita.forward(60)
tortuguita.left(105)
tortuguita.forward(100 / math.sqrt(2))
tortuguita.left(45)
tortuguita.end_fill()

# La base del árbol
tortuguita.penup() 
tortuguita.goto(100, -130)
tortuguita.pendown()
drawRectangle(tortuguita, 20, 40, "brown")

# La copa del árbol
tortuguita.penup() 
tortuguita.goto(65, -90)
tortuguita.pendown()
drawTriangle(tortuguita, 90, "lightgreen")
tortuguita.penup() 
tortuguita.goto(70, -45)
tortuguita.pendown()
drawTriangle(tortuguita, 80, "lightgreen")
tortuguita.penup() 
tortuguita.goto(75, -5)
tortuguita.pendown()
drawTriangle(tortuguita, 70, "lightgreen")

# El sol
tortuguita.penup() 
tortuguita.goto(55, 110)
tortuguita.fillcolor("yellow")
tortuguita.pendown()
tortuguita.begin_fill()
tortuguita.circle(24)
tortuguita.end_fill()

# Los rayos del sol
tortuguita.penup()
tortuguita.goto(55, 134)
tortuguita.pendown()
drawFourRays(tortuguita, 25, 24)
tortuguita.right(45)
drawFourRays(tortuguita, 15, 24)
tortuguita.left(45)

# Etiquetas de los elemntos que dibujaos
tortuguita.color("black")
tortuguita.penup()
tortuguita.goto(-150, 70)
tortuguita.pendown()
tortuguita.write("Casa", None, None, "14pt bold")
tortuguita.penup()
tortuguita.goto(150, -150)
tortuguita.pendown()
tortuguita.write("Arbol", None, None, "14pt bold")
tortuguita.penup()
tortuguita.goto(130, 150)
tortuguita.pendown()
tortuguita.write("Sol", None, None, "14pt bold")

# Traemos la tortuguita cerca a la puerta!
tortuguita.penup()
tortuguita.goto(-100, -150)
tortuguita.left(90)

¿Pero qué es un paralelogramo?

Ahora que tenemos construidas nuestras funciones, vamos a usarlas para dibujar los elementos de la casita, con las características que queramos!

Ta rá! Este es el dibujo que obtenemos cuando ejecutamos todo el código.

🤩
🥳
💻
replit
turtle
math
https://www.edufichas.com/matematicas/teorema-de-pitagoras/
https://www.universoformulas.com/matematicas/geometria/paralelogramo/