
Explore turtle graphics to draw vectors, grids, and polygons using Python 3000, mastering Cartesian geometry, absolute and relative coordinates, fractals, and custom fonts and bitmaps.
Download the appropriate archive for your training level and extract it to the folder inside. Access Python turtle graphics examples, lab solutions, support files, and demonstrations for the training.
Learn how turtle graphics in Python 3 use the Cartesian plane to plot and move objects with x and y axes, origin at zero, and multiple turtles.
Explore python turtle graphics as object-oriented modeling on a Cartesian plane. Import the turtle package in Python 3, move forward, and call done to verify a three line program.
Explore turtle graphics as a robot-like drawing tool, using orientation and degrees to move from the origin and draw a right angle.
Explore Python's turtle graphics on a Cartesian plane, comparing go to and home, and use forward, left, and aliases to draw a crosshair from origin.
Explore how the default turtle owns window properties, uses setup to set width, height, and starting x and y location, and title to customize, while other turtles cannot access them.
Learn to draw polygons with turtle graphics by using relative headings, turning right 90 degrees, and looping with range to create squares and other shapes.
Learn to draw polygons by expanding from a square to an octagon, using 360 degrees divided by eight, and update your previous turtle graphics solution.
Master polygon drawing with Python's turtle by using 360 degrees divided by sides, and implement draw_poly with a default length of 50 to create shapes of varying sizes.
Apply sanity checks on the number of sides, iterate over a zero-based range, compute length and angle, and return the result or negative one if drawing the polygon fails.
Use vector-based graphics and the draw poly capability to construct a grid with turtle graphics, drawing squares and advancing across rows to form a 4x4 grid.
Explore an object oriented approach to drawing fast grids with Python's turtle. Create a reusable draw grid class that renders serpentine lines, supports borders, and multiple grids at custom positions.
Explore grid classes in Python's Turtle Graphics, including slow grid, slow ro, and a snake grid with serpentine drawing, heading management, and reusable draw square methods.
Explore Python turtle graphics by drawing a seven-sided heptagon with draw poly, and examine rounding to two significant digits, positions, and coordinate control via go to and set position.
Explore turtle graphics speed control in Python, learn to set and read speed, adjust update delay, and test minimum and maximum speeds.
Explore common pen operations in Python's turtle graphics, including default speeds, headings, and pen properties, while drawing a 20-sided polygon and practicing a dotted-line pattern.
colorized quadrants demonstrates drawing a four-colored square with red, black, gold, and green using turtle graphics, while teaching pen color and width management, pen up/down, and state restoration.
Explore stack management with a state saver to snapshot and restore the drawing environment using a push and pop paradigm, and organize code as a reusable module.
explain the state saver solution for python turtle graphics, detailing a state module with color and position, push and pop operations, and optional function execution for testing in python 3.
Master turtle graphics state management by resetting and clearing screen, returning to home, and toggling visibility across multiple turtles. Build a cartesian cross with pen size, colors, and text input.
Explore fractals with turtle graphics by building black-box functions for draw poly, using a complex plane with x, y, and z, and applying two-digit rounding and nonzero axes.
Plot fractals with turtle graphics using calc poly and Z angle, counting valid points and ensuring uniqueness while managing pen states to reveal irregular fractal patterns.
Shift the origin to a lower-left zero, zoom into fractal plots, and explore transforms and the calc poly function to plot points at scale while preserving a rigid fractal definition.
Explore fractals with Python's turtle graphics by building the Sierpinski arrowhead and a recursive fractal tree, revealing how recursion, angles, and line lengths generate complex patterns.
Explore Python's turtle graphics with fractal tree customization, speeding up rendering, adding color, and controlling depth and thresholds to create richer fractal models.
Explore how characters become glyphs in turtle graphics by using Python 3's Unicode and UTF encodings (utf-8/utf-16) and a simple cipher that maps name characters to offsets and encrypted values.
Explore Unicode concepts by triggering and addressing a Unicode encoder error, understanding codec limitations, and enabling Unicode support in Python windows applications.
Explore how font encoding affects rendering, baselines, and alignment across fonts and platforms, and learn to tweak positions for precise glyph placement in Unicode and bitmap contexts.
Render an eight by eight chessboard with turtle graphics using utf-8 unicode glyphs and fonts, while managing pen and fill colors and drawing filled polygons.
Explore building a chessboard using Python's turtle graphics, introducing a reusable Xboard class, z board and z cell helpers, and font-based rendering with zero-based coordinates and speed control.
Explore a flexible turtle graphics framework for rendering a chessboard, with per-cell positioning using x and y coordinates, scalable cell length, font tweaks, and programmable cell prints.
Explore how vector-based fonts scale with a scaling factor in Python's turtle graphics. Discover Hershey fonts, TrueType fonts, and SVG alongside a hands-on glyph exercise using move and line commands.
Import the turtle module, plot points with selective pen up and down to form a star, and explore inverting the y axis to align Hershey's glyphs with the Cartesian plane.
Explore scaling vector graphics in turtle graphics by flipping the y coordinate and increasing or decreasing size to zoom in on drawings.
Learn to draw at a location by adding position to x and y, enabling scalable, reusable glyphs via an ordered dictionary and a V shape function.
Explore Python's turtle graphics to build professional simulations and reusable models on 2d and 3d canvases, using graphical frameworks, Cartesian planes, and callback functions to capture user input.
Master input processing for turtle graphics, handling text and floating-point input, none on cancel, implement a calculator with plus, minus, multiply, divide, quitting on zero or q, and display result.
Build a Python turtle graphics calculator by using a turtle dot by function, a title font, looping to refresh the screen, reading two inputs, and evaluating an expression with eval.
Alias turtle as robot to draw rectangles using go to, left, and right with extents; set pen and fill colors with begin_fill and end_fill for reusable field rects.
Learn how to manage turtle graphics input using text and numeric prompts, set defaults, handle none values, and draw filled shapes by restoring state, applying colors, and drawing a rectangle.
Define boxer class to manage on-click shapes in Python's turtle graphics, establishing defaults for pen color, fill color, and pen size 3 with a 100 box size, and draw boxes.
Extend turtle graphics beyond simple shapes using a vector-based shape class to draw arbitrary polygons and circles with begin fill and end fill.
Build a state saver for the turtle, preserving position, foreground color, and background color, by duplicating state.pi into a stack, updating imports and class name, and testing push and pop.
Explore best patterns and pattern practices for turtle graphics by designing a miniature framework that uses a single function, parameter dictionary, and callbacks within a model-view-controller approach to draw shapes.
Discover how python's turtle graphics can be turned into printable 3d objects via cura and openscad, share on thingiverse, and explore affordable 3d printing with simple lab exercises.
Develop a data-driven turtle graphics framework that draws squares, circles, and other shapes by parameter changes, enabling easy reuse with generators and state saving.
Explore turtle graphics to manage 2D updates for 3D printing, drawing circles and rectangles, controlling pen color, width, and fill, and using Unicode symbols to create coins and chess pieces.
Load bitmaps such as png, gif, and jpg and render them in a wysiwyg, dot-for-dot view, while setting background color and window size first for accurate scaling.
Explore turtle graphics to draw circles and convert them into polygons by adjusting radius, extent, and steps, demonstrating how arc degrees map to line segments.
Configure the turtle screen and pen, set a fixed radius and 360-degree divisions to draw polygons from triangles to octagons with alternating colors, spacing shapes by the diameter.
Learn dynamic circle drawing with on-the-fly size changes, heading control, and incremental pen width for evolving patterns. Reuse prior work to integrate a 360-degree draw circle routine into existing frameworks.
Explore a turtle-based test driver that uses an enumerator to draw circles, color by dictionary values, adjust pen size, and position via angles for partial shapes.
Explore turtle graphics to track headings and distances, preserve circle points, and report distance from home in the console. Practice 45-degree steps to draw a circular pattern.
Explore alternate color representation by applying hex codes for red, green, and blue to generate the circle pattern in lab poly five, while adjusting the range for an extra point.
Explore turtle graphics by mapping circle degrees to customizable steps, including 360 degrees to 100 steps, while expressing angles in radians with math.pi and 25%, 50%, 75%, and 100% portions.
Apply a phased, agile research process to evolve turtle graphics for drawing circles with variable degrees per slice, from 360 to 100, using quartile representations.
Learn how world coordinates in turtle graphics let you zoom and skew drawings by adjusting the lower left and upper right coordinates.
Upgrade turtle graphics by configuring a dyme-based world with screen size, viewport, and world coordinates, then apply skew, aspect ratios, and timed renders for flexible, recordable views.
Explore Python's turtle graphics by undoing drawn operations with an undo buffer. Set a ten-entry limit, draw shapes, and iterate buffer entries to undo actions and inspect steps.
Investigate undo buffers in Python's Turtle Graphics by testing 300 and 1000 points to reveal how many rendering iterations—736 in this case—are stored for real-time drawing.
Explore modeling and simulation with Python's Turtle graphics, covering cartesian planes, vector graphics, shapes, user input, fonts, frameworks, and 3D model techniques for transforming, event handling, and timer-based simulations.
Explore five ways to manage shapes in Python's turtle graphics, including predefined default shapes, user-defined shapes, active shapes, undo history, and size and resize modes.
Learn to assign and stamp turtle shapes using a default or registered shape registry, adjust size and colors, and manage stamped objects with IDs and clear stamp operations.
Demonstrate managing times and shapes in turtle graphics by stamping named shapes, delaying with sleep, and clearing them via their IDs to animate circles and squares.
Register external images as turtle shapes using a gif file like myimage.gif in the shape registry and stamp them; bitmaps cannot rotate or auto-scale, so use point-based shapes for flexibility.
Master framework integration by registering only gif shapes, using a target class to count callbacks, and drawing a turtle from a data array, with stars as a bonus.
Enumerate points for reusable shapes like the star and inner circle, register them by shape name, and draw scalable turtles by unpacking a size tuple into three parameters.
Merge multiple polygons into a compound shape with the turtle shape class, register it, and stamp varied sizes to demonstrate complex shape registration and manipulation.
Learn to register color-named turtle shapes and draw red, blue, green, and yellow diamonds using size and position data, with a flight recorder to create complex polygons.
Explore turtle graphics and a polygraph recording routine to construct polygons and circles from points, starting and ending at the origin. Zooming reveals more complex shapes and skewed patterns.
Explore tilt and set tilt angle in turtle graphics, comparing additive tilts with absolute tilts. Learn how aliases and the shape registry support stamping and transformations for animations.
Define a coin shape in turtle graphics using absolute positioning and size, stamp a data-driven pattern with a framework, and compare tilt angle while noting speed trade-offs and GitHub code.
Explore applying shear factors and shape transforms in turtle graphics, and understand how the shape transform matrix controls x and y skew, symmetry, and exceptions.
Explore turtle graphics shape transformations using six-sided symmetry, positive and negative transforms, and circular transforms, while observing how head of the turtle and pen settings drive rendering.
Explore how turtle graphics handles events using the Hollywood model, registering keyboard and mouse callbacks to control the screen, colors, and shapes in an interactive demo.
Learn how to implement an on key class that manages colors and shapes, registers callbacks, and handles toggle, color cycling, zoom, and quit with bounds checks to prevent overflow.
Master mouse motion and events in Python's turtle graphics by implementing callback signatures, onClick and onDrag handlers, and button mappings, with coordinate translation and stamping shapes.
Explore managing multiple turtle instances, each with unique properties, by inheriting from a base turtle and using per-instance onClick events to change color, shape, fill, and direction, plus identity.
Master visual testing with a test driver and setup that customizes turtle colors, shapes, and onClick events, then explore z order and hit testing.
Learn to implement on-timer callbacks in the turtle graphics framework, schedule and cancel with milliseconds (t=0 to cancel), and build a one-second heartbeat clock for time-based animations.
Explore a turtle graphics clock model that animates a red active dot on a gray clock face, recoloring prior positions and using a Clocker class with timer-driven ticks.
Apply turtle graphics to real-world gear modeling, animation, and simulation, exploring pinwheel and spike gears, 2D patterns, and timer-driven motion for practical design.
Explore how two spiked gears synchronize around a fixed center of rotation by adjusting the intergear spire length in a Python turtle gear motion simulator.
Reuse an external shape data file to drive two turtles with spike gear shapes, using two shapes and adjusting distance to enable coexistence and create a polygon-based antique clock wiggle.
This course has got it all ... from testing, robotics, frameworks, simulation, animation, classical Cartesian and as well as modern computerized drawing planes you'll never enjoy a more comprehensive coverage of both Python's "batteries included" graphics module as well as professional programming practices.
Starting with the clear and universally understandable geometric classics - by the time you've completed my Turtle Graphics Training I personally guarantee you that you'll be ready for the professional software development world.
We’ve even a demonstration on how to print your design on 3D printers.
Graphical Math
Throughout this training series students will be practicing their knowledge of how to use Python lists, tuples, dictionaries, functions, and classes to create graphical designs.
No longer three (3) separate opportunities, this unified educational opportunity now combines the 3000, 4000, and 5000 tracks (*) into one:
Level 3000
The first of a three-part educational experience, in this Python 3000: Turtles, Robots and Vectors educational opportunity students will be building upon their Python 3 programming experience. Complex programming concepts such as loops, blocks, and if-then-else statement and even collections can be graphically stepped-through as any shape is propelled over any 2D or 3D coordinate-plotting strategies.
In this Python 3000 level opportunity we will begin by drawing shapes using programmable vector-graphics. We will discover how Python's built-in graphical operations can be used to visualize complex programming, as well as classical mathematical, concepts.
Fonts & Graphical Simulations
Along the way, this Level 3000 educational opportunity reviews many graphical concepts, such as Cartesian Geometry, as well as a coordinate-free vector-based way to use Turtle-Graphics. We will demonstrate, as well as practice both techniques to create grids, polygons, as well as to display both shapes and fonts; the type of operations we're going to need to complete the Python 4000, and 5000, lessons.
Exploring vector-based fonts and Fractals, in this session we will also develop several reusable techniques. Best practices designed to help us master Python's classic mathematical and graphical plane.
Level 4000
The Python 4000: Graphical Events and Operations lesson set ushers past our basic understandings of plotting & motion-based shapes to allow us to create graphical frameworks -Design patterns that will allow us to call our functions within Python's classical Cartesian graphics plane. Along the way we will also discover how to graphically gather input from application users, as well.
If you're not familiar with how to create and use frameworks, or have never used a callback function, then I think you will find our intermediate training - or Python 4000 for Turtle Graphics - to be something that you don't want to miss. --Certainly a lesson set that you'll want to re-use, as well as practice!
Level 5000
In Python 5000: Cartesian Frameworks we will reuse what we have learned - frameworks and best-practices - to create and animate different many graphical designs & models.
A seldom taught feature, in Level 5000 we also will discover how to use Python's built-in Shape Registry. We will understand how to record - as well as to replay - complex vector operations. From external bitmaps, to vector graphics the surprising resizable & adaptable cursor can allows us to drag-and-drop items around our screens.
Finally you will understand what is required to create real-world software while practicing how to detect, collect, and to respond to keyboard, mouse, timer, input, and other real-world events. Highly reusable concepts & design patterns that professional software developers use to better manage, as well as to maintain complex software systems.
(*) The source-code solutions archives for each level can be downloaded to your computer from the last lesson of each Section.