The Koch Snowflake¶

This project draws a fractal curve, with only a few lines of turtle graphics code. It assumes you know about for-loops and functions. And it introduces the computer science idea of recursion.

The basic unit¶

Start the project by making an empty file `koch.py`. Right-click and open it with IDLE.

We’re going to define a function that either draws a line with a kink in it, or draws a straight line the same length. Which one it does will depend on whether the argument `order` is greater than zero. Type this in the editor, save it (ctrl-S) and run it (F5):

```# Draw a Koch snowflake
from turtle import *

def koch(a, order):
if order > 0:
for t in [60, -120, 60, 0]:
forward(a/3)
left(t)
else:
forward(a)

# Test
koch(100, 0)
pensize(3)
koch(100, 1)
```

The symbol `>` means “greater than”. Be careful about the indenting (the spaces before each line). You should get this: Recursion¶

This is where your head explodes. You will replace the `forward(a/3)` with another call to `koch`, to draw a kinked line of the same length. That’s a line with 4 parts, …

• and each of those parts has 4 parts,
• and each of those parts has 4 parts,
• and each of those parts has 4 parts, …

Well, not in practice. In practice, the variable `order` goes down by one each time, and when it hits zero, we just draw a line. Change the function `koch`, just a little:

```        for t in [60, -120, 60, 0]:
koch(a/3, order-1)
left(t)
```

When a function calls itself, we say it is recursive. Recursion can solve problems that simple iteration (like a for-loop) cannot.

Save and run. You will get the same two curves as before, because of the test code. But try this in the shell:

```>>> reset()
>>> koch(100, 2)
```

Now each line segment has become a Koch curve. There are 16 little lines. What happens for `koch(100,3)` or `koch(100,4)`? The order 4 curve has 256 tiny lines. One thing that happens is that it starts to take a long time to draw. A call to `speed("fastest")` before you start drawing will help.

Need for speed¶

The drawing is still too slow once `order` is 6 or more. (The calculation is fast.) The `turtle` module wants to show you every change as it is happening: good when debugging, not so good when you just want the result.

We can delay putting the actions on the screen with the `tracer` function. But then we have to tell it to appear using the `update` function, when we’re ready.

Looks like snow¶

The snowflake is made from 3 Koch curves. Although there are only 3 “sides”, it has 6-fold symmetry, like a real snowflake.

Delete the test code from your program, and add this program at the end:

```# Choose colours and size
color("sky blue", "white")
bgcolor("black")
size = 400
order = 0

# Ensure snowflake is centred
penup()
backward(size/1.732)
left(30)
pendown()

# Make it fast
tracer(100)
hideturtle()

begin_fill()

# Three Koch curves
for i in range(3):
koch(size, order)
right(120)

end_fill()

# Make the last parts appear
update()
```

Save and run. This should give you a big, white triangle. Adjust `size` so it nicely fills the drawing window when run. Now set `order` to 6 or 7. Run the program and enjoy the result.

How many sides does this have? (Hint: every time the order goes up by one, there are 4 times as many.)