Create Amazing Graphics with Python

Introduction

This project demonstrates how to create stunning fractal tree graphics using Python’s Turtle module. A fractal tree is a recursive structure that repeats a simple pattern at smaller scales, creating complex and intricate designs. The Turtle module is perfect for drawing such graphics because of its simple commands and ability to visualize recursion easily.

Prerequisites

To work on this project, you should have:

Basic knowledge of Python programming.
Familiarity with functions and recursion in Python.

Learning Objectives

By the end of this project, you will:

Understand how to use Python’s Turtle module for graphics.
Learn the concept of recursion and how to implement it.
Gain experience in creating fractal patterns using simple geometric transformations.

Installation Guide

To run this project, you need to have Python installed on your system. You can download it from python.org.

Install Python: Follow the instructions on the Python website to install Python for your operating system.
Install Turtle module: Turtle is included in the Python standard library, so you don’t need to install it separately. Just ensure that Python is properly installed.

Project Steps

Initialize the Turtle environment: Set up the screen and the Turtle object.
Define a recursive function: Create a function that draws a branch of the tree, reducing its length at each step.
Call the function multiple times: Draw multiple branches with different angles and lengths to form a fractal tree.
Customize colors and speed: Use different colors and adjust the speed for visual appeal.

Code

				
					import turtle as tu

roo = tu.Turtle()        # Turtle object
wn = tu.Screen()         # Screen Object
wn.bgcolor("black")      # Screen Bg color
wn.title("Fractal Tree Pattern")
roo.left(90)             # moving the turtle 90 degrees towards left
roo.speed(20)            # setting the speed of the turtle

def draw(l):             # recursive function taking length 'l' as argument
    if (l < 10): return
    else:
        roo.pensize(2)          # Setting Pensize
        roo.pencolor("yellow")  # Setting Pencolor as yellow
        roo.forward(l)          # moving turtle forward by 'l'
        roo.left(30)            # moving the turtle 30 degrees towards left
        draw(3 * l / 4)         # drawing a fractal on the left of the turtle object 'roo' with 3/4th of its length
        roo.right(60)           # moving the turtle 60 degrees towards right
        draw(3 * l / 4)         # drawing a fractal on the right of the turtle object 'roo' with 3/4th of its length
        roo.left(30)            # moving the turtle 30 degrees towards left
        roo.pensize(2)
        roo.backward(l)         # returning the turtle back to its original psition
        
draw(20)  # drawing 20 times
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("magenta")  # magenta
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("red")  # red
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)

def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("lightgreen")  # lightgreen
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("red")  # red
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("yellow")  # yellow
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)

def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("cyan")  # cyan
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("yellow")  # yellow
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("magenta")  # magenta
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
wn.exitonclick()

Code

				
					import turtle as tu

roo = tu.Turtle()        # Turtle object
wn = tu.Screen()         # Screen Object
wn.bgcolor("black")      # Screen Bg color
wn.title("Fractal Tree Pattern")
roo.left(90)             # moving the turtle 90 degrees towards left
roo.speed(20)            # setting the speed of the turtle

def draw(l):             # recursive function taking length 'l' as argument
    if (l < 10): return
    else:
        roo.pensize(2)          # Setting Pensize
        roo.pencolor("yellow")  # Setting Pencolor as yellow
        roo.forward(l)          # moving turtle forward by 'l'
        roo.left(30)            # moving the turtle 30 degrees towards left
        draw(3 * l / 4)         # drawing a fractal on the left of the turtle object 'roo' with 3/4th of its length
        roo.right(60)           # moving the turtle 60 degrees towards right
        draw(3 * l / 4)         # drawing a fractal on the right of the turtle object 'roo' with 3/4th of its length
        roo.left(30)            # moving the turtle 30 degrees towards left
        roo.pensize(2)
        roo.backward(l)         # returning the turtle back to its original psition
        
draw(20)  # drawing 20 times
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("magenta")  # magenta
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("red")  # red
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(3 * l / 4)
        roo.right(60)
        draw(3 * l / 4)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(20)

def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("lightgreen")  # lightgreen
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("red")  # red
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor("yellow")  # yellow
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(3)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(4 * l / 5)
        roo.right(60)
        draw(4 * l / 5)
        roo.left(30)
        roo.pensize(3)
        roo.backward(l)

draw(40)

def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("cyan")  # cyan
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("yellow")  # yellow
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.left(270)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor("magenta")  # magenta
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
roo.right(90)
roo.speed(2000)

# recursion
def draw(l):
    if (l < 10): return
    else:
        roo.pensize(2)
        roo.pencolor('#FFF8DC')  # white
        roo.forward(l)
        roo.left(30)
        draw(6 * l / 7)
        roo.right(60)
        draw(6 * l / 7)
        roo.left(30)
        roo.pensize(2)
        roo.backward(l)

draw(60)
wn.exitonclick()

Pseudo Code explaining this Python Project

				
					The pseudo code for drawing the fractal tree is as follows:
function draw(length)
    if length < 10
        return
    else
        set pen size and color
        move forward by length
        turn left by 30 degrees
        draw(3/4 of length)
        turn right by 60 degrees
        draw(3/4 of length)
        turn left by 30 degrees
        move backward by length

Pseudo Code explaining this Python Project

				
					The pseudo code for drawing the fractal tree is as follows:
function draw(length)
    if length < 10
        return
    else
        set pen size and color
        move forward by length
        turn left by 30 degrees
        draw(3/4 of length)
        turn right by 60 degrees
        draw(3/4 of length)
        turn left by 30 degrees
        move backward by length

Flow Chart

Code Explanation

Turtle Initialization: The turtle roo is initialized to draw the tree. The turtle’s speed and initial direction are set up.
Recursive Function: The draw function is defined to draw branches of the tree recursively. If the length of the branch is less than 10, the recursion stops.
Branch Drawing: For each recursive call, the turtle draws a branch, turns left, and draws the left subtree, then turns right to draw the right subtree.
Color and Pensize: Different colors and pen sizes are used to enhance the visual appeal of the fractal pattern.
Multiple Patterns: The draw function is called multiple times with different lengths and colors to create a diverse fractal design.

Challenges and Solutions

Understanding Recursion: Recursion can be complex, especially when visualizing its effect. Start with smaller values for l to see how recursion works.
Turtle Speed: The turtle may draw slowly with complex patterns. Increasing the speed using roo.speed(2000) helps visualize the pattern faster.
Color Overlap: Overlapping colors can make the pattern less appealing. Adjust the angles and branch lengths to reduce overlap.

Testing

Modify Parameters: Experiment with different lengths, angles, and colors to see how the pattern changes.
Edge Cases: Test with very small values for l to ensure the recursion stops as expected.

Additional Resources

Turtle Graphics Documentation
Introduction to Recursion in Python

FAQs

What is the Turtle module used for?
The Turtle module is used for creating simple graphics and drawings in Python. It provides a virtual canvas to visualize drawings through a turtle object.
How does recursion work in this project?
Recursion is used to draw branches of the fractal tree by calling the same function with a reduced branch length, creating a self-similar pattern.
Can I use different shapes for the branches?
Yes, you can experiment with different angles, shapes, and sizes for the branches by modifying the turtle’s movements in the draw function.
How can I save the generated pattern as an image?
You can use screen capture tools to save the window as an image, or use the turtle.getcanvas().postscript() method to export the drawing.
Why does the turtle move back after drawing a branch?
Moving back to the original position ensures that the turtle is correctly positioned to draw the next branch without overlapping with the previous one.

Project by Harshil Bansal and Documented by Aakarsh Pandey, Team edSlash.