Creative graphics and interactive demos using Python Turtle
Learn Programming • Create Art • Build Interactive Applications
This repository showcases creative graphics projects and interactive applications built with Python's Turtle Graphics module. From drawing programs to generative art, these demos demonstrate how Turtle can be used for both learning programming fundamentals and creating impressive visual applications.
Perfect for beginners learning Python, educators teaching programming concepts, or anyone interested in creative coding!
Note: Demo applications were created with assistance from Google Gemini and Claude AI, and refined through experimentation.
|
|
Explore the creative possibilities of Python Turtle Graphics!
|
📚 Beginner Friendly Perfect for learning Python basics |
🎨 Visual Feedback See your code come to life instantly |
🔧 Built-in Module No external dependencies needed |
🌈 Creative Expression Art, patterns, and animations |
- Python 3.x installed on your system
- Turtle module (included with Python standard library)
No additional installation required! 🎉
-
Clone this repository:
git clone https://github.com/NguyenLe15325/Python-turtle.git cd Python-turtle -
Run any demo:
python paint.py # or python fractals.py -
Create and explore!
- Follow on-screen instructions for controls
- Experiment with colors and patterns
- Modify code to create your own designs
Progress through these demos to master Turtle Graphics:
1. 🟢 Basic Drawing (Simple shapes, lines)
↓ Learn turtle movement and pen control
2. 🟡 Interactive Input (Click handling, keyboard events)
↓ Understand event-driven programming
3. 🟠 Complex Patterns (Loops, functions, recursion)
↓ Create sophisticated designs
4. ⚫ Full Applications (Paint program, games)
↓ Build complete interactive projects
5. 🎨 Your Masterpiece!
Create original artwork or tools
This interactive drawing application demonstrates the full capabilities of Python Turtle Graphics. It features a complete toolkit for creating digital artwork, including multiple drawing tools, color selection, and canvas management—all built with Python's standard library!
-
🖌️ Multiple Drawing Tools
- Pencil — Freehand drawing
- Brush — Thicker lines
- Eraser — Remove mistakes
- Fill tool — Color regions
- Shapes — Circles, rectangles, lines
-
🎨 Color System
- Color palette with preset colors
- Custom color picker
- RGB slider controls
- Recently used colors
-
📐 Drawing Controls
- Adjustable pen size (1-50 pixels)
- Pen up/down for disconnected lines
- Undo/redo functionality
- Clear canvas option
-
💾 Save & Load
- Export drawings as PostScript (.eps)
- Save canvas state
- Load previous work
-
🎛️ User Interface
- Toolbar with tool icons
- Color palette display
- Size slider
- Status bar showing current tool and color
| Input | Action |
|---|---|
Left Click |
Draw with current tool |
Right Click |
Pick color from canvas |
Mouse Drag |
Continuous drawing |
1-9 |
Quick select pen size |
C |
Open color picker |
E |
Switch to eraser |
P |
Switch to pencil |
B |
Switch to brush |
U |
Undo last action |
R |
Redo |
Ctrl+S |
Save drawing |
Ctrl+Z |
Undo |
Ctrl+Y |
Redo |
Delete |
Clear canvas |
Core Components:
class PaintApp:
"""Main application class managing the paint program"""
def __init__(self):
self.screen = turtle.Screen()
self.canvas = turtle.Turtle()
self.current_tool = "pencil"
self.current_color = "black"
self.pen_size = 3
self.setup_ui()
def draw(self, x, y):
"""Handle drawing on canvas"""
if self.is_drawing:
self.canvas.goto(x, y)
def change_color(self, color):
"""Update drawing color"""
self.current_color = color
self.canvas.color(color)
def setup_ui(self):
"""Create toolbar and color palette"""
self.create_toolbar()
self.create_palette()
class ColorPalette:
"""Manages color selection interface"""
def __init__(self, x, y):
self.colors = [
"#000000", "#FFFFFF", "#FF0000", "#00FF00",
"#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"
]
self.draw_palette(x, y)
def on_click(self, x, y):
"""Handle color selection clicks"""
selected = self.get_color_at(x, y)
return selected
class DrawingTool:
"""Base class for different drawing tools"""
def __init__(self, name, size, color):
self.name = name
self.size = size
self.color = color
def use(self, x, y):
"""Apply tool at coordinates"""
passEvent Handling:
def setup_events(app):
"""Configure mouse and keyboard events"""
screen = app.screen
# Mouse events
screen.onclick(app.on_click)
screen.onscreenclick(app.on_click, btn=1) # Left click
screen.onscreenclick(app.pick_color, btn=3) # Right click
# Keyboard shortcuts
screen.onkey(app.undo, "u")
screen.onkey(app.clear_canvas, "Delete")
screen.onkey(app.save, "s")
# Enable listening
screen.listen()- Event-Driven Programming — Mouse clicks, drags, and keyboard input
- State Management — Tracking current tool, color, and drawing state
- UI Design — Creating toolbars, palettes, and interactive elements
- Object-Oriented Design — Classes for tools, colors, and canvas management
- Graphics Programming — Coordinate systems, transformations, and rendering
- File I/O — Saving and loading drawings
- User Experience — Undo/redo, visual feedback, and intuitive controls
Extend the paint program with these features:
- Layer System — Multiple drawing layers with transparency
- Text Tool — Add text with different fonts and sizes
- Stamps & Stickers — Pre-made shapes and images
- Gradient Tool — Smooth color transitions
- Symmetry Mode — Mirror drawing for mandala effects
- Animation Export — Record drawing process as video
- Pressure Sensitivity — Variable line thickness (with tablet support)
- Filters & Effects — Blur, brightness, contrast adjustments
- Grid & Guides — Alignment helpers
- Custom Brushes — Create brush patterns and textures
What you can create with the paint program:
- 🌸 Mandalas — Symmetrical geometric patterns
- 🌄 Landscapes — Simple scenic artwork
- 🎭 Pixel Art — Grid-based designs
- ✏️ Sketches — Freehand drawings and doodles
- 📐 Diagrams — Technical illustrations
- 🌈 Abstract Art — Colorful creative expressions
- Turtle Academy — Interactive turtle graphics lessons
- Python for Kids - Turtle Graphics
- Trinket - Python Turtle Examples
Explore the beauty of recursive patterns with fractal drawing algorithms. Create stunning mathematical art including:
- Koch Snowflake — Classic fractal pattern
- Sierpinski Triangle — Self-similar triangular fractal
- Dragon Curve — Space-filling dragon pattern
- Tree Fractals — Recursive branching structures
Generate mesmerizing geometric patterns using loops and mathematical functions:
- Spirals — Fibonacci, Archimedean, and golden spirals
- Rose Curves — Mathematical rose patterns
- Star Polygons — Multi-pointed star shapes
- Tessellations — Repeating tile patterns
Simple games demonstrating game logic with Turtle:
- Snake Game — Classic growing snake
- Pong — Paddle and ball mechanics
- Maze Runner — Navigate through generated mazes
- Catch Game — Reflexes and timing
This project is licensed under the MIT License — see the LICENSE file for details.
You're free to use, modify, and distribute this code for personal or commercial projects.
Python Turtle Graphics — Built-in Python module for creative programming
The Python Community — For tutorials, examples, and endless inspiration
Google Gemini & Claude AI — AI assistance in generating and refining demo code
ezgif.com — GIF editing and optimization tools
Creative Coding Community — Artists and educators sharing their work
Nguyen Le • @NguyenLe15325