Arte: Generando arte recursivo

import turtle


def draw(my_turtle, lenght):
    if lenght:
        my_turtle.forward(lenght)
        my_turtle.left(123)
        draw(my_turtle, lenght - 2)


if __name__ == "__main__":
    my_turtle = turtle.Turtle()
    screen = turtle.Screen()

    colors = (
        '#006699',
        '#006666',
        '#660066',
        '#990000',
        '#ad3270',
        '#e65100',
        '#1a237e',
        '#827717',
        '#006064',
        '#f57f17',
        '#d50000',
        '#4a148c',
    )

    for color in colors:
        my_turtle.pencolor(color)
        draw(my_turtle, 100)

    screen.exitonclick()

Les comparto un proyecto parecido que hice mientras estaba de intercambio 😄
Era sobre usando turtle, crear de forma recursiva los troncos de un árbol ( de forma aleatoria )

# Name: Carlos N. Trejo Garcia
# Date: 03/23/18

#Imports
import turtle
import random

#Creates a branch of a tree
def tree(branchLen,t):
    LIMIT = 5 #Limit for minimum length of the tree

    #Check if the length is grather than the limit
    if branchLen > LIMIT:

        #Get the lengths of the next two branches
        left = branchLen - getLen()
        right = branchLen - getLen()

        #Acorrding to those lengths, check to see if this one is the last one
        #If it is, then this one is sa leaf. So use color green
        #Else, use color brown
        if amItheLast(left, right, LIMIT):
            t.color("green")
        else:
            t.color("brown")

        #The size of the pen is proporcional of the length
        t.pensize(branchLen * .12)
        #Print forward
        t.forward(branchLen)

        #Get angles of next two branches
        rig = getAngle()
        lef = getAngle() + rig
        ret = t.heading() #Store for return later

        #Go to the right
        t.right(rig)
        tree(left, t)

        #Go to the left
        t.left(lef)
        tree(right, t)

        #Return to original angle, stop drowing with the pen and go back
        t.setheading(ret)
        t.up()
        t.backward(branchLen)
        t.down() #Continue drowing

#Returns if the actual branch is the last one (leaf?)
#@Lef: Length of left branch - INT
#@Rig: Length of right branch - INT
#@Limit: The limit of the lenght in order to be draw - INT
def amItheLast(lef, rig, limit):
    if lef > limit or rig > limit:
        return False
    else:
        return True

#Get a random angle, between 15 and 45
def getAngle():
    return random.randint(15,45)

#Get a random length, between 5 and 20
def getLen():
    return random.randint(5,20)
    
#Creates and prints a tree
def main():
    #Pencile and canvas
    t = turtle.Turtle()
    myWin = turtle.Screen()

    #Set start position
    t.shape("turtle")
    t.left(90)
    t.up()
    t.backward(100)
    t.down()

    #Start drawing
    tree(75,t)
    myWin.exitonclick()

main()

No hay nada mas lindo en recursividad que los fractales!

Mi código para el copo de von Koch

import turtle

tortuga = turtle.Turtle()
ventana = turtle.Screen()

def dibujar(tortuga, largo):
    if largo >40:
        dibujar(tortuga,largo/3)
        tortuga.left(60)
        dibujar(tortuga,largo/3)
        tortuga.right(120)
        dibujar(tortuga,largo/3)
        tortuga.left(60)
        dibujar(tortuga,largo/3)
    else:
        tortuga.forward(largo/3)
        tortuga.left(60)
        tortuga.forward(largo/3)
        tortuga.right(120)
        tortuga.forward(largo/3)
        tortuga.left(60)
        tortuga.forward(largo/3)


if __name__ == "__main__":

    dibujar(tortuga,500)
    ventana.exitonclick()

Me encantó esta clase, me recuerda a la tortuguita logo con la que aprendí a programar sin saber que estaba programando.

Para quien no sepa de qué les estoy hablando les dejo un link que habla de Logo.

Secuencia de Fibonacci 😄

Muchachos no se por qué a mi no me funcionaba el ejercicio con el compilador que usan en el ejemplo. Me salía este error:

Tuve que usar el mismo compilador pero con un enlace diferente, ya que el error era al importar la librería turtle.
Este es el enlace por si a alguien le sirve: https://repl.it/languages/python_turtle

El código está en el comentario anterior

🐍🎨

![](

import turtle

tr = turtle.Turtle()
win = turtle.Screen()

def draw(tr, length):

    if length > 0:
        tr.forward(length)
    else:
        tr.backward(length)

    tr.left(135)
    draw(tr, length -2)

draw(tr, 100)
win.exitonclick()

https://repl.it/languages/python_turtle

el enlace para correr el programa

Asi me quedo a mi

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

colors = (
        '#006699',
        '#006666',
        '#660066',
        '#990000',
        '#ad3270',
        '#e65100',
        '#1a237e',
        '#827717',
        '#006064',
        '#f57f17',
        '#d50000',
        '#4a148c',
    )

def draw(myTurtle, length):
    if length > 0: 
        myTurtle.forward(length)
        myTurtle.left(170)
        draw(myTurtle, length-10)

for color in colors:
        myTurtle.pencolor(color)
        draw(myTurtle, 100)```

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()


def draw(myTurtle,length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.right(60)
        myTurtle.left(-60)
        
        draw(myTurtle, length -2)

draw(myTurtle, 100)
myWin.exitonclick()```

esta super el arte recursivo con python

Hice algunos experimentos diferentes!

Me gusto mucho esta clase! 😃

What do you think?

Código:

import turtle

angle = 0;
myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    global angle
    if length > 0:
        myTurtle.forward(length)
        if angle%2 == 0:
            myTurtle.left(120)
        else:
            myTurtle.left(160)
        angle += 1
        draw(myTurtle, length-1)

draw(myTurtle, 100)
myWin.exitonclick()

Adjunto arte recursivo

![](

Recrusive-Art
El nombre es casi poético. Aquí mi primer experimento exitoso con el código.

Mi implementacion con cosas random y algo abstracto haha

import turtle
import random

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.color(getColor())
        myTurtle.pensize(length * .12)
        myTurtle.forward(length)
        myTurtle.left(getAngle())
        draw(myTurtle, length - 3)

def getAngle():
    return random.randint(20, 90)

def getColor():
    colores = ["red", "green", "blue", "yellow", "brown", "pink", "orange", "black"]
    return random.choice(colores)

draw(myTurtle, 100)
myWin.exitonclick()

No es mucho pero es trabajo honesto:

import turtle

myTurtle = turtle.Turtle()
window = turtle.Screen()


def draw(myTurtle, length):
    if length > 72:
        myTurtle.forward(length)
        myTurtle.left(150)
        draw(myTurtle, length - 2)


if __name__ == '__main__':
    draw(myTurtle, 120)
    window.exitonclick()

Encontré este ejemplo en la red, pero pareció muy bueno:

bob.getscreen().bgcolor('#994444')
bob.penup()
bob.goto((-200,100))
bob.pendown()

def star(turtle,size):
    if size <= 10:
        return
    else:
        turtle.begin_fill()
        for i in range(5):
            turtle.forward(size)
            star(turtle,size/3)
            turtle.left(216)
        turtle.end_fill()
star(bob,360)
turtle.done()
bob.exitonclick()

Créditos: https://github.com/KeithGalli/Turtle-Python
https://www.youtube.com/watch?v=pxKu2pQ7ILo&t=1276s

Y hace esto…

![](

Recursividad imparable!!!

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
  if length > 0:
    myTurtle.forward(length)
    myTurtle.left(90)
    draw(myTurtle, length-10)

draw(myTurtle, 100)
myWin.exitonclick()

Nunca le llamen a su archivo turtle.py 😉

Adicione un poco de color

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

colors=['red','purple','blue','green','yellow','orange']

def draw(myTurtle, length):
	if length > 0:
		myTurtle.pencolor(colors[length%6])
		myTurtle.forward(length)
		myTurtle.left(60)
		draw(myTurtle, length - 5)

draw(myTurtle, 100)
myWin.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length, boolean):
    if length > 0:
        # empieza if boolean == true

        if boolean == True:
            myTurtle.pencolor('yellow')
        elif boolean == False:
            myTurtle.pencolor('orange')

        # fin if boolean == True

        myTurtle.forward(length)
        myTurtle.left(120)
        
        # empieza if boolean == true
        if boolean == True:
            draw(myTurtle, length-2, False)
        else:
            draw(myTurtle, length-2, True)

        # fin if boolean == true
        


draw(myTurtle, 200, True)
myWin.exitonclick()

aqui va el mio 😃

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.left(320)
        draw(myTurtle, length-1.9)

draw(myTurtle, 100)
myWin.exitonclick()

aqui va el otro bastante entretenido dibujar tambien me fije que el giro que da el puntero hacia donde dibujar despues del retroceso eliminado mas lineas bastante interesante

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.left(120)
        draw(myTurtle, length-2)

draw(myTurtle, 100)
myWin.exitonclick()

!

😃

Alguien tenía que hacerlo. Por las dudas solo dejo el código y si quieren pruebenlo:

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    for i in range(0,4):
        myTurtle.pensize(5)
        myTurtle.right(90)
        myTurtle.forward(length)
    myTurtle.forward(length*2)
    for i in range(0,3):
        myTurtle.right(90)
        myTurtle.forward(length)
    myTurtle.forward(length*3)
    myTurtle.left(90)
    myTurtle.forward(length)
    myTurtle.left(90)
    myTurtle.forward(length*3)

        



draw(myTurtle, 100)

myWin.exitonclick()

Mi dibujo en espiral.

import turtle #turtle es una libreria que permite dibujar haciendo un recorrido

myTurtle = turtle.Turtle() #iniciamos la libreria
myWin = turtle.Screen() # la pantalla donde va a deibuajr nuestra turtle

myTurtle.speed(100) # velocidad de la turtle
myTurtle.pensize(20) # grosor 
myTurtle.color("green")
myTurtle.forward(400)

def draw(myTurtle, length):
  if length > 10:
    if length > 70 :
        myTurtle.color(255, 204, 0)
        myTurtle.forward(length) #va a avanzar cuanto de legth pixeles este
        myTurtle.left(100) # va a ir a la izquierda
        draw(myTurtle, length-1) #y luego se va a volver a llamar pero restandole al recorrido
    else:
        myTurtle.color("brown")
        myTurtle.forward(length) #va a avanzar cuanto de legth pixeles este
        myTurtle.left(100) # va a ir a la izquierda
        draw(myTurtle, length-1) #y luego se va a volver a llamar pero restandole al recorrido

draw(myTurtle,200) 
myWin.exitonclick() #cuando le demos click se va a salir

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()
turtle.bgcolor('black')
turtle.screensize(600,600)


def draw( myTurtle, length ):
    if length > 0:

        if(length%2==0):
            myTurtle.color('cyan')
            myTurtle.left(30)  # angulo
        else:
            myTurtle.color('red')
            myTurtle.left(170)  # angulo

        myTurtle.forward(length)
        draw(myTurtle,length-1) #Reduccion

draw(myTurtle, 200)
myWin.exitonclick()

En esta página pueden correr su código

https://trinket.io/python

soporta turtle (o trinket, que es como lo encontré)

No caí en cuenta que este ya nadie lo ve jajaj,pero bueno quería entender la librería en vez de ponerme a copiar y pegar y medio cambiarle algo.

si llega a 25 likes comparto código completo jaja 😂

El enlace de replit ya no funciona pero se puede probar el codigo en https://www.pythonsandbox.com/turtle

Esta pagina también funciona, por si no pueden con el enlace o si no quieren registrarse:
https://trinket.io/turtle

import turtle

#Declarando funciones como variables para hacer mas facil su escritura. 
myTurtle = turtle.Turtle()
my_window = turtle.Screen()

def draw(myTurtle, lenght):
    if lenght > 0:
        myTurtle.forward(lenght)
        myTurtle.left(120)
        draw(myTurtle, lenght-15)



if __name__ == "__main__":
    
    colors = (
        '#006699',
        '#006666',
        '#660066',
        '#990000',
        '#ad3270',
        '#e65100',
        '#1a237e',
        '#827717',
        '#006064',
        '#f57f17',
        '#d50000',
        '#4a148c',
    )

    for color in colors:
        myTurtle.pencolor(color)
        draw(myTurtle, 100)

    my_window.exitonclick()

Siguiendo el gráfico de airsoull puedes modificar el my_turtle.left(123) por my_turtle.left(246) y quedará un gráfico asi.

![](

Además consultando un poco encontré este código para poder realizar el siguiente gráfico.

import turtle
colors = ['red', 'purple', 'blue', 'green', 'orange', 'yellow']
t = turtle.Pen()
turtle.bgcolor('black')
for x in range(360):
    t.pencolor(colors[x%6])
    t.width(x/100 + 1)
    t.forward(x)
    t.left(59)

![](

Un último dato para hacer que el background donde se realiza el gráfico sea negro solo se debe agregar: turtle.bgcolor(‘black’).

Cordial saludo Comunidad

Una vez validado los comentarios de algunos estudiantes, les comparto lo que estoy aprendiendo:

import turtle
import random
#take the control of drawing
window = turtle.Screen()
#change the backgroud color
window.bgcolor('black')

random_colors = ['#0ca90c', '#c20d0d', '#ffffff', '#ffd700']
#create the turtle that will draw on the canvas
tortuga = turtle.Turtle()
#select the speed from 1 to 10 where 10 is the fastest
tortuga.speed(5)
#cartesian axis put the origin of drawing, default turtle start in 0 and heading to the right.
tortuga.left(90)

#basic command without recursivity and only one branch.

#Drawing the branch
# tortuga.forward(100)
#Setting to start drawing the branch to the left
# tortuga.left(30)
#Draw branch
# tortuga.forward(50)
#Comeback the turtle to the position before
# tortuga.backward(50)
#Setting to start drawing the branch to the right
# tortuga.right(60)
#Draw branch
# tortuga.forward(50)
#Comeback the turtle to the position before
# tortuga.backward(50)
#Comeback the turtle to the angle
# tortuga.left(30)
# tortuga.backward(100)

#RECURSIVITY FOR DRAWING BRANCHES

def drawtree(sizeBranch, tortuga):
    tortuga.pensize(sizeBranch/10)
    if (sizeBranch < 40):
        tortuga.dot(random.randint(7, 10), random.choice(random_colors))
        return 
    tortuga.forward(sizeBranch)
    tortuga.left(30)
    drawtree(sizeBranch*random.uniform(0.8, 0.9), tortuga)
    tortuga.right(60)
    drawtree(sizeBranch*random.uniform(0.8, 0.9), tortuga)
    tortuga.left(30)
    tortuga.backward(sizeBranch)
#start drawing 
tortuga.penup()
tortuga.setpos(0, -200)
tortuga.pendown()
tortuga.hideturtle()
tortuga.color('green')

#Call the function for 100 Length
drawtree(100, tortuga)

window.exitonclick()```

Quedo muy atento a sus comentarios, la fuente donde ví el proyecto completo fue:
https://www.youtube.com/watch?v=9PW_m_ffOWY&t=1004s

Slds
Hollman.

Los invito a ver mi blogpost sobre recursión y fractales 😄:

https://jcalvarezj.blogspot.com/2020/11/la-esencia-de-la-recursion.html

Aquí exploro la recursión un poco más “en esencia” dando unos ejemplos con fractales (también incluyo enlace a mi repositorio de código para dibujar algunos fractales con Python Turtle)

Muy buena clase!

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0: 
        myTurtle.forward(length)
        myTurtle.left(90)
        draw(myTurtle, length-10)

draw(myTurtle, 100)
myWin.exitonclick()

Alguien conoce otra página para correr python, no me quiso funcionar.

Dibujando una estrella

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 100:
        myTurtle.forward(length)
        myTurtle.right(288/2)
        draw(myTurtle, length-2)

draw(myTurtle, 200)
myWin.exitonclick()


Solo cambie un poco el angulo y el length

def drawTurtle(myTurtle, length):
    if(length > 0):
        myTurtle.forward(length)
        myTurtle.left(120)

        drawTurtle(myTurtle, length-10)


drawTurtle(myTurtle, 400)
myWindow.exitonclick()

![](

)

![](

Una recursividad sin condición…

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
  if length > 0:
    myTurtle.forward(length)
    myTurtle.left(90)
    draw(myTurtle, length-10)

draw(myTurtle, 100)
myWin.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, lenght):
    if lenght > 0:
      myTurtle.forward(lenght)
      myTurtle.right(70)
      draw(myTurtle, lenght-2)

draw(myTurtle,100)
myWin.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, lenght):
    if lenght > 0:
      myTurtle.forward(lenght)
      myTurtle.right(70)
      draw(myTurtle, lenght-2)

draw(myTurtle,100)
myWin.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.left(90)
        draw(myTurtle, length - 1)

draw(myTurtle, 100)
myWin.exitonclick()

como se hace esto en java?

Amazing

No entiendo, por más que reviso el código me aparece esto en la página:
![](

![](

excelente clase, gracias Ricardo

no puedo observar la imagen a formar .

escribá un codigo donde el ángulo es random, lo que genera dibujos interesantes,
tambien puedes colocar el ángulo estático si deseas al quitar el comentario de la lìnea que está debajo de length y comentando la línea donde aparece radomint

import turtle
import random


def turtle_draw(my_turtle, length):
    angle = random.randint(1,50)

    if length > 0:
        my_turtle.forward(length)
        my_turtle.left(angle)
        turtle_draw(my_turtle, length - 1)


if __name__ == '__main__':
    my_turtle = turtle.Turtle()
    windows = turtle.Screen()

    length = int(input('¿Cual es el tamaño de las lìneas?: '))
#   angle = int(input('¿Cual es el angulo de cruce?: '))

    turtle_draw(my_turtle, length)
    windows.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
if length > 0:
myTurtle.forward(length)
myTurtle.left(23)
draw(myTurtle, length-2)

draw(myTurtle, 100)
myWin.exitonclick()

import turtle

myTurtle = turtle.Turtle()
myWin =turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.left(90)
        myTurtle.backward(length)
        myTurtle.right(45)
        draw(myTurtle, length-5)


draw(myTurtle, 100)
myWin.exitonclick()```

<co![](url)de>

Aqui mi codigo:

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()
colors = (
        '#006699',
        '#006666',
        '#660066',
        '#990000',
        '#ad3270',
        '#e65100',
        '#1a237e',
        '#827717',
        '#006064',
        '#f57f17',
        '#d50000',
        '#4a148c',
    )

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.left(120)
        draw(myTurtle, length-2)

for color in colors:
  myTurtle.pencolor(color)
  draw(myTurtle, 150)
  myWin.exitclick()```

wow

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen() 

def dibujar(myTurtle, linea):
    if(linea > 0):
        myTurtle.forward(linea)
        myTurtle.left(60)
        dibujar(myTurtle, linea - 3)

dibujar(myTurtle, 300)
myWin.exitonclick()

Anexo dibujo

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.right(72)
        draw(myTurtle, length-5)


draw(myTurtle, 300)
myWin.exitonclick()```

import turtle

myTurtle = turtle.Turtle()
myWin = turtle.Screen()

def draw(myTurtle, length):
    if length > 0:
        myTurtle.forward(length)
        myTurtle.right(120)
        myTurtle.left(80)
        myTurtle.right(240)
        myTurtle.left(45)
        draw(myTurtle, length - 2)

draw(myTurtle, 100)
myWin.exitonclick()

Logré hacer una estrella… o algo así 😃

no se que paso… me podrian ayudar porfa