How To Draw A Tree In Python Turtle

Creating fractals with Python

Try it yourself in this postal service!

Commencement of all, what is a geometric fractal? A geometric fractal is a geometric shape with a repeating structure at different scales: it doesn't matter whether y'all go closer to the image or not, you'll e'er see the same pattern. Or, every bit defined past Benoit Mandelbrot, "a rough or fragmented geometric shape that tin be carve up into parts, each of which is (at least approximately) a reduced-size copy of the whole".

Now, how can we build a fract a 50 in Python? Given that we are repeating a structure at different scales, we'll need to utilise a recursive solution. Moreover, we'll be using turtle to draw the fractals. In this post, nosotros'll be cartoon both a fractal tree and a Koch snowflake.

Drawing a fractal tree

In gild to create a tree, nosotros are going to divide each branch into ii sub-branches (left and right) and shorten the new sub-branches, until nosotros reach a minimum branch length, defined by ourselves:

          import turtle          MINIMUM_BRANCH_LENGTH = 5          def build_tree(t, branch_length, shorten_by, angle):
            pass          tree = turtle.Turtle()
tree.hideturtle()
tree.setheading(90)
tree.color('light-green')          build_tree(tree, 50, 5, 30)
turtle.mainloop()

So far, we've but defined the basics. We've imported turtle and created an instance of turtle.Turtle(), which will be the object moving around the canvas and drawing our tree. Nosotros've then made it face upward with setheading(). Nosotros've also divers the signature of our recursive function, which volition be the following:

t: our Turtle instance.
branch_length: the current length of the co-operative in pixels.
shorten_by: determines by how many pixels the sub-branches will be shorter than the parent branch.
angle: the angles from which the sub-branches emerge from the parent co-operative.

Moreover, we've defined the MINIMUM_BRANCH_LENGTH (in pixels), which sets the minimum threshold to create further sub-branches.

Permit's now build the body of our recursive office:

          import turtle          MINIMUM_BRANCH_LENGTH = 5          def build_tree(t, branch_length, shorten_by, angle):
            if branch_length > MINIMUM_BRANCH_LENGTH:
            t.forrard(branch_length)
            new_length = branch_length - shorten_by                      t.left(angle)
            build_tree(t, new_length, shorten_by, bending)                      t.right(angle * 2)
            build_tree(t, new_length, shorten_by, angle)                      t.left(bending)
            t.astern(branch_length)          tree = turtle.Turtle()
tree.hideturtle()
tree.setheading(90)
tree.colour('greenish')          build_tree(tree, 50, five, xxx)
turtle.mainloop()

As you lot can see, nosotros achieve our base case if branch_length is lower than MINIMUM_BRANCH_LENGTH. Otherwise, nosotros depict the branch and proceed to create the sub-branches by calculating their length and turning left and correct by "angle" degrees and calling build_tree again with the new values. Finally, nosotros movement backwards to the root of our co-operative.

If you lot execute the code y'all should obtain the following event:

Finally, experience gratuitous to play around with the code (and the parameters) hither!

Drawing a Koch snowflake

In the second section of this mail we'll exist cartoon a more circuitous structure: the Koch snowflake.

Offset of all, we'll need to create a recursive office to create the Koch bend, and so we'll exist joining three of these curves to create a snowflake. Let'southward start by defining the parameters of our recursive function:

t: our Turtle case.
iterations: represents the value of northward in the image below this list (note that n=0 would correspond a apartment line, which will be the base case in our recursive part).
length: the length of each side in our current (sub-)snowflake.
shortening_factor: determines the factor by which the side length is divided when nosotros create a new sub-snowflake.
angle: determines the angle from which the new side emerges.

Once we have defined the basic structure of our recursive role, nosotros may reach the following betoken:

          import turtle          def koch_curve(t, iterations, length, shortening_factor, angle):
            pass          t = turtle.Turtle()
t.hideturtle()          for i in range(3):
            koch_curve(t, 4, 200, iii, 60)
            t.right(120)          turtle.mainloop()

At this point, we just have to implement the recursive function. If we have reached our base case, we'll just draw a line. Otherwise, we'll update our parameters (specifically, iterations and length) and telephone call our recursive function 4 times. Between these function calls nosotros'll be turning start to the left, then to the right and finally to the left over again. Let's run into how the full implementation looks:

          import turtle          def koch_curve(t, iterations, length, shortening_factor, angle):                      if iterations == 0:
            t.forward(length)
            else:
            iterations = iterations - 1
            length = length / shortening_factor                      koch_curve(t, iterations, length, shortening_factor, angle)
            t.left(bending)
            koch_curve(t, iterations, length, shortening_factor, angle)
            t.correct(angle * 2)
            koch_curve(t, iterations, length, shortening_factor, angle)
            t.left(angle)
            koch_curve(t, iterations, length, shortening_factor, angle)          t = turtle.Turtle()
t.hideturtle()          for i in range(3):
            koch_curve(t, 4, 200, 3, 60)
            t.correct(120)          turtle.mainloop()