Bienvenido al Curso

1

Introducción al curso básico de algoritmos y estructuras de datos

Introducción a los algoritmos

2

¬ŅQu√© entiende una computadora?

3

Lenguajes de programación

4

Estructuras de datos

5

¬ŅQu√© es un algoritmo?

6

Metodología para la construcción de un algoritmo

7

Variables y tipos de datos

8

User defined data types

9

Instalando Ubuntu Bash en Windows

10

Creando nuestro user defined data type

11

Abstract Data Types b√°sicos: Lists, Stacks, Queues

12

Explicación gráfica Data Types básicos

13

Glosario de funciones para Abstract Data Types

14

Clases y objetos

15

Creando tu primera Queue: Arrays

16

Creando tu primera Queue: implementación.

17

Creando tu primera Queue: implementar la función enQueue

18

Creando tu primera Queue: implementar la función deQueue

19

Creando tu primera Queue: main code

Algoritmos de ordenamiento

20

Algoritmos de ordenamiento

21

Bubble sort

22

Bubble sort: implementación

23

Bubble sort: main code

24

Insertion sort

25

Desafío: implementa un algoritmo de ordenamiento

Recursividad

26

Recursividad

27

La función Factorial, calculando el factorial recursivamente

28

Manejo de cadenas de caracteres

29

Arte: Generando arte recursivo

Divide and conquer y programación dinámica

30

Divide and Conquer (divide y vencer√°s)

31

Qué es la programación dinámica (divide y vencerás v2.0)

32

MergeSort

33

Desafío: Buscar el algortimo más rápido de sort

34

Implementando QuickSort con Python

35

Implementando QuickSort con Python: main code

Algoritmos 'Greedy'

36

Qué son los Greedy Algorithm

37

Ejercicio de programación greedy

38

Ejercio de programación greedy: main code

Grafos y √°rboles

39

Grafos y sus aplicaciones

40

√Ārboles

¬ŅC√≥mo comparar Algoritmos?

41

Cómo comparar algoritmos y ritmo de crecimiento

¬ŅQu√© sigue?

42

Cierre del curso y siguientes pasos

No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Arte: Generando arte recursivo

29/42
Recursos

Ya vas entendiendo la recursividad a la perfecci√≥n, ¬Ņverdad?

No s√≥lo podemos hacer operaciones recursivas con textos y n√ļmeros; el l√≠mite es tu imaginaci√≥n. En esta clase aprender√°s a dibujar figuras geom√©trica usando funciones recursivas y controlando √°ngulos con la librer√≠a turtle de Python (viene incluida por defecto, no debes instalar nada).

Aportes 166

Preguntas 4

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

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.

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

Secuencia de Fibonacci ūüėĄ

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()

![](C:\0-Resources\Projects\CursosPlatzi\Fund - Algoritmos\arteTurtle pythonRecursivo.png)

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()```
Muy interesante.

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