105 lines
2.5 KiB
Python
105 lines
2.5 KiB
Python
import turtle
|
|
import sys
|
|
sys.setrecursionlimit(1000000)
|
|
|
|
def draw_square(t, size):
|
|
|
|
t.forward(size / 2)
|
|
t.left(90)
|
|
t.forward(size)
|
|
t.left(90)
|
|
t.forward(size)
|
|
t.left(90)
|
|
t.forward(size)
|
|
t.left(90)
|
|
t.forward(size / 2)
|
|
|
|
# draw_square(turtle, 100)
|
|
|
|
def draw_recursive_stairs(t, size, steps):
|
|
if steps == 0:
|
|
return
|
|
t.left(90)
|
|
t.forward(size)
|
|
t.right(90)
|
|
t.forward(size)
|
|
draw_recursive_stairs(t, size, steps - 1)
|
|
|
|
# draw_recursive_stairs(turtle, 20, 5)
|
|
|
|
def draw_recursive_tree(t, size, größe):
|
|
if größe == 0:
|
|
return
|
|
t.forward(size)
|
|
t.left(30)
|
|
draw_recursive_tree(t, size * 0.7, größe - 1)
|
|
t.right(60)
|
|
draw_recursive_tree(t, size * 0.7, größe - 1)
|
|
t.left(30)
|
|
t.backward(size)
|
|
#turtle.left(90)
|
|
#draw_recursive_tree(turtle, 100, 5)
|
|
|
|
|
|
# Ich möchte einen Code schreiben der erst ein 64 Quadrat zeichnet
|
|
# und dann rekursiv immer zwei halb so große Quadrate oben links und rechts über das ursprüngliche Quadrat zeichnet.
|
|
# Bis die Seitenlänge = 1 ist.
|
|
# Es soll nur eine Turtle geben, die wiederverwendet wird.
|
|
|
|
|
|
def draw_recursive_squares(t, length, x, y):
|
|
if length < 1:
|
|
draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
|
|
return
|
|
x = t.xcor()
|
|
y = t.ycor()
|
|
|
|
|
|
t.penup()
|
|
t.goto(x + length * 1.5 , y + length * 2.5)
|
|
t.pendown()
|
|
|
|
|
|
draw_square(t, length)
|
|
|
|
|
|
|
|
draw_recursive_squares(t, length / 2, x - length * 2.5, y + length * 2.5)
|
|
#square = draw_square(turtle, 64)
|
|
#turtle.speed(10)
|
|
#draw_recursive_squares(turtle, 32, 0,0)
|
|
|
|
|
|
t = turtle.Turtle()
|
|
t.speed(2000)
|
|
#t.speed(0)
|
|
|
|
def square_recursion(t, length, x, y):
|
|
if length < 8:
|
|
return
|
|
print(length)
|
|
t.penup()
|
|
t.goto(x, y)
|
|
t.pendown()
|
|
draw_square(t, length)
|
|
square_recursion(t, length / 2, x - length * 1.5, y + length * 1.5)
|
|
square_recursion(t, length / 2, x + length * 1.5, y + length * 1.5)
|
|
|
|
|
|
#square_recursion(t, 64, 0, 0)
|
|
#turtle.done()
|
|
|
|
# Jetzt möchte ich eine Kochkurve zeichnen, die rekursiv immer kleinere Dreiecke zeichnet.
|
|
def draw_koch_Kurve(t, length, depth):
|
|
if depth == 0:
|
|
t.forward(length)
|
|
return
|
|
t.forward(length / 3)
|
|
t.left(60)
|
|
draw_koch_Kurve(t, length / 3, depth - 1)
|
|
t.right(120)
|
|
draw_koch_Kurve(t, length / 3, depth - 1)
|
|
t.left(60)
|
|
draw_koch_Kurve(t, length / 3, depth - 1)
|
|
|
|
draw_koch_Kurve(t, 300, 10) |