Python para todos: crea tu árbol de Navidad

Paloma Recuero de los Santos    23 diciembre, 2020
Abeto de Navidad

Para estas fechas navideñas, nos hemos propuesto jugar un poco con Python para ver cómo podríamos dibujar un árbol de Navidad. Empezaremos con algo muy sencillito y luego probaremos con la librería gráfica Turtle. La idea es animaros a experimentar y crear vuestro propio árbol, según vuestro nivel de conocimientos.

1. Un sencillo bucle for

Para crear este primer árbol usaremos dos sencillos bucles for, y las funciones random y print.

El bucle for que no es más que una estructura de control que repite un bloque de instrucciones, el cuerpo del bucle, un número predeterminado de veces. Cada repetición es una iteración. La sintaxis del bucle for es la siguiente:

for variable in elemento iterable (lista, cadena, range, etc.):
cuerpo del bucle

El cuerpo del bucle se ejecuta tantas veces como elementos tenga el elemento iterable (elementos de una lista o de un range(), caracteres de una cadena, etc.). No es necesario definir la variable de control «i» antes del bucle, pero se puede utilizar una variable ya definida en el programa.

También usaremos la función range, que devuelve una secuencia de números entre el valor inicial (start) y el final (stop), con un intervalo dado (step), y la función print, que muestra el objeto que se le pasa como parámetro en el dispositivo de salida elegido. Su sintaxis es:

print(object(s), sep=separator, end=end, file=file, flush=flush)

El código para nuestro árbol es el siguiente:

#Primer bucle, range(start,stop,step)
for i in range(1,30,2):
print(('^'*i).center(30))

for leg in range(3):
print(('|||').center(30))
print(('\_____/').center(30))
print(' '+30*'-')
print('(¨¨¨)¡Feliz Navidad! (¨¨¨)')

Y el resultado:

Reconozcámoslo, es un árbol muy sencillo, pero para empezar, no está mal ¿no?. Vamos a por el siguiente.

2. Nuestro árbol con Turtle

Los gráficos de tortuga (Turtle graphics) formaban parte del lenguaje de programacion Logo, desarrollado por por Wally Feurzeig, Seymour Papert y Cynthia Solomon en 1967. Por su sencillez y atractivo, se han usado mucho para enseñar programación utilizado como método para enseñar programación a través de coordenadas relativas a niños y mayores.

Cómo dibujar con Turtle Graphics

La «tortuga (turtle) es un objeto que se desplaza sobre el plano de coordenadas x-y y nos permite dibujar todo tipo de figuras. Tiene 3 atributos esenciales:

  • Posición: Respecto al centro de coordenadas.
  • Orientación: Dirección hacia donde mira la tortuga.
  • Pluma: Rastro que puede dejar la tortuga al desplazarse.

Para desplazar nuestro objeto turtle disponemos de funciones como:

  • forward(distance): Avanzar una determinada cantidad de píxeles.
  • backward(distance): Retroceder una determinada cantidad de píxeles.
  • left(angle): Girar hacia la izquierda un determinado ángulo.
  • right(angle): Girar hacia la derecha un determinado ángulo.

A menos que especifiquemos lo contrario, al desplazarse la tortuga pinta un rastro. Si queremos que se desplace sin dejar rastro, podemos usar las funciones:

  • home(distance): Desplazarse al origen de coordenadas.
  • goto((x, y)): Desplazarse a una coordenada en concreto.
  • penup(): Subir el lápiz para no mostrar el rastro.
  • pendown(): Bajar el lápiz para mostrar el rastro.

También podemos cambiar el color, grosor o forma y tamaño de la punta del lápiz:

  • shape(‘turtle’): Cambia al objeto tortuga.
  • pencolor(color): Cambiar al color especificado.
  • pensize(dimension): Tamaño de la punta del lápiz.

Árbol de Navidad con Python Turtle

Python es un lenguaje que soporta el paradigma de Programación Orientada a Objetos, y en este caso nuestro objeto va a ser el puntero (turtle) que vamos a utilizar para dibujar una figura.

Como siempre, lo primero que tenemos que hacer es importar la librería que permite utilizar las funciones de movimiento de la tortuga.

#Importamos el módulo turtle que permite crear gráficos de tortuga 

import turtle

A continuación, creamos la ventana para dibujar, indicando sus dimensiones y posición. También podemos ponerle el título que queramos.

Para que no quede el fondo blanco, hemos buscado un fondo navideño, y lo hemos guardado en el directorio de trabajo. (Si no tenemos claro cuál es, podemos averiguarlo con os.getcwd()). Para no complicarnos demasiado con los tamaños, hemos ajustado el tamaño de la ventana al de la imagen.

Esta es la imagen de nuestro fondo:

# Generamos una instancia de la clase screen de turtle 
screen = turtle.Screen()

# Con los métodos setup y title establezco propiedades (tamaño y nombre de la ventana)
screen.setup(1200,700,0,0)
screen.title("Nuestro árbol de Navidad en Python")

# Con el método bgpic cambiamos el atributo "fondo" (el fichero png debe estar en el directorio de trabajo, os.getcwd())
screen.bgpic("fondonavidad.png")

# Al definir el tamaño de la ventana ya hemos tenido en cuenta el del fondo que hemos elegido 

El siguiente paso será definir nuestro lápiz o tortuga («turtle»). Le daremos distinta forma y color según lo que queramos dibujar. Para dibujar el árbol, veremos que las formas estándar «square» y «circle» nos vienen bien.

#Definimos el lápiz con el que vamos a dibujar el árbol y sus adornos


# Generamos una instancia de la subclase Turtle (pen) de turtle, es decir un "lápiz"
# Con los métodos shape, colour y speed, definimos su aspecto y a qué velocidad se va a mover (más adelante, en el bucle)
# Levantamos el cursor para que no pinte hasta que le digamos dónde debe hacerlo

lapiz = turtle.Turtle()
lapiz.up()

Vamos a definir una imagen no estándar para la estrella que corona el árbol. Para ello, usaremos el método register_shape y un gif con tamaño adecuado. (También podíamos haber ajustado el tamaño desde dentro del programa, pruébalo si quieres investigar un poco más). Una vez definido el lápiz como «estrella», dibujamos la estrella con el método stamp.

# Empezamos por ¡el tejado!: la estrella
# Definimos una forma especial para el "pen" basado en un gif con estrella con fondo transparente mediante el método register_shape 
# El gif, con el tamaño adecuado, en este caso 50*50 píxeles, debe estar en el directorio de trabajo

screen.register_shape("star5.gif")
lapiz.shape('star5.gif')
 

#Lo llevamos a la posición que queremos y pintamos
lapiz.goto(0,310)
lapiz.stamp()

A partir de la estrella, continuamos dibujado el árbol. Para ello usaremos un bucle que dibujará 16 filas de cuadrados verdes. Definimos el lápiz como cuadrado verde, y dibujamos la parte derecha del árbol. A continuación, dibujamos la parte izquierda.

Una vez dibujado el árbol en sí, lo adornaremos con bolas rojas y amarillas. Pondremos bolas rojas en las filas que son múltiplos de 3, por ejemplo, y amarillas en las múltiplos de 5.

Por último, volvemos a definir el lápiz como cuadrado marrón para dibujar el tronco con un último bucle muy sencillo.

(Para elegir los colores, seguro que os viene bien esta página)

# Para pintar el árbol vamos a usar un bucle
# Inicializo k, el árbol lo forman 16 filas de cuadrados verdes

k = 0
for i in range(1, 17):
    y = 30*i
# Definimos lapiz cuadrado y verde #138808
    lapiz.shape('square')
    lapiz.color('#138808')
    lapiz.speed('fastest')
    for j in range(i-k):
        x = 30*j
        
# Dibujamos la parte derecha del árbol, 
        lapiz.goto(x,-y+300)
        lapiz.stamp()
# Dibujamos la parte izquierda del árbol
        lapiz.goto(-x,-y+300)
        lapiz.stamp()

# Colocamos las bolas rojas en las filas que son múltiplos de 5. Definimos lapiz redondo y amarillo (##ffff31)

    if i % 5 == 0:
        x =  30*(j+1)
        lapiz.shape('circle')
        lapiz.color('#ffff31')
        lapiz.speed('fastest')
      
        lapiz.goto(-x,-y+300)
        lapiz.stamp()
        lapiz.goto(x,-y+300)
        lapiz.stamp()        
        k += 3
        
# Colocamos las bolas rojas en las filas impares. Cambiamos color del lapiz a rojo (red)

    if i % 3 == 0:
        x =  30*(j+1)
        lapiz.shape('circle')
        lapiz.color('red')
        lapiz.goto(-x,-y+300)
        lapiz.stamp()
        lapiz.goto(x,-y+300)
        lapiz.stamp() 

# Dibujamos el tronco del árbol. Volvemos a lapiz cuadrado, y color marrón
lapiz.shape('square')
lapiz.color('#cc5500')
for i in range(14,20):
    y = 30*i
    for j in range(2):    
        x = 30*j
        
        lapiz.goto(x,-y+200)
        lapiz.stamp()
        lapiz.goto(-x,-y+200)
        lapiz.stamp()        
        
turtle.exitonclick()

Eh voilá!, ya tenemos nuestro arbolito navideño. ¡Felices Fiestas!

Para mantenerte al día con LUCA visita nuestra página web suscríbete a LUCA Data Speaks o síguenos en TwitterLinkedIn YouTube.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *