Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Graphics for Pythoneers
Rating: 4.4 out of 5(10 ratings)
8,468 students

Graphics for Pythoneers

From Robots to Frameworks - Complete Course!
Last updated 8/2025
English
English [Auto],

What you'll learn

  • Use Python to plot points upon the classical mathematical plane
  • Create and manipulate colorized polygons
  • Scale and manage vector-based graphics
  • Use Python's built-in Cartesian text sub-system
  • Use over 3,400 additional vector-based glyphs & textual characters
  • Understand how to create several grid types, as used to create a colorized chess board
  • Understand how to draw special / international Unicode characters
  • Understand the basics of font creation, usage, as well as common glyph-rendering strategies
  • Create a basic calculator
  • Determine relative point-distances
  • Determine object heading & orientation
  • Create & manage the "Undo Buffer"
  • Use screen-relative viewports
  • Scale the global, world-coordinate, aspect ratios
  • Understand how to manage shape transformations
  • Respond to mouse events & keyboard operations
  • Create Lambdas to respond to framework events
  • Register user-defined shapes
  • Record & transform basic, as well as complex, shapes
  • Learn how to create a "Z Order" to manage user events
  • Understand the difference between shapes, the shape registry, and active-object instances
  • Simulate basic object movement & instance inter-operations

Course content

3 sections85 lectures9h 51m total length
  • 3.0100: Lesson Orientation1:56

    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.

  • 3.0110: Getting Started2:00

    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.

  • 3.0200: Introduction to Cartesian Planes6:36

    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.

  • 3.0300: Basic Lines & Orientations6:21

    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.

  • 3.0400: Common Angles5:44

    Explore turtle graphics as a robot-like drawing tool, using orientation and degrees to move from the origin and draw a right angle.

  • 3.0500: Goto Points7:08

    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.

  • 3.0600: The Main Turtle4:50

    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.

  • 3.0700: Drawing Polygons4:42

    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.

  • 3.0800: Polygons - Part 20:57

    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.

  • 3.0810: Polygons - Part 32:52

    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.

  • 3.0820: Polygons - Part 41:25

    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.

  • 3.0900: Object-Oriented Pitfalls (The "Slow Grid")5:58

    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.

  • 3.1000: The "Fast Grid"11:26

    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.

  • 3.1100: Which is Best? Grid Classes8:05

    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.

  • 3.1200: Polygon Case Study (3's and 7's)6:42

    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.

  • 3.1300: Turtle Speeds7:19

    Explore turtle graphics speed control in Python, learn to set and read speed, adjust update delay, and test minimum and maximum speeds.

  • 3.1400: Common Pen Operations7:50

    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.

  • 3.1500: Colorized Quadrants - Joseph One12:14

    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.

  • 3.1600: State Saver - Joesph Two4:15

    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.

  • 3.1700: State Saver Solution11:42

    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.

  • 3.1800: The Cartesian "Map Marker"6:59

    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.

  • 3.1900: Drawing Fractals7:44

    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.

  • 3.2000: More Fractals!8:38

    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.

  • 3.2100: A Plausible "Fractal Framework"?6:26

    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.

  • 3.2200: Fractal Tree11:27

    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.

  • 3.2300: Fractal Tree Customization7:36

    Explore Python's turtle graphics with fractal tree customization, speeding up rendering, adding color, and controlling depth and thresholds to create richer fractal models.

  • 3.2400: Concept Review: Creating a Super Secret Cypher?4:48

    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.

  • 3.2500: Unicode Concepts2:13

    Explore Unicode concepts by triggering and addressing a Unicode encoder error, understanding codec limitations, and enabling Unicode support in Python windows applications.

  • 3.2600: Additional Encoding Concepts10:36

    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.

  • 3.2700: Chess Board - Part One11:16

    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.

  • 3.2800: Chess Board - Part Two14:09

    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.

  • 3.2900: Chess Board - Part Three7:29

    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.

  • 3.3000: Vector-Based Fonts10:35

    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.

  • 3.3100: Inverting & Aligning Vector-Based Shapes3:57

    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.

  • 3.3200: Scaling Vector-Based Shapes2:12

    Explore scaling vector graphics in turtle graphics by flipping the y coordinate and increasing or decreasing size to zoom in on drawings.

  • 3.3300: Classical Vector-Font Families, Re-Use & Support5:11

    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.

Requirements

  • Students should have experience using Python 3
  • Python 3.x should be installed
  • Python's Turtle Module must be installed (i.e: `import turtle` should work!)
  • Students should have completed Python 1000, Python 2000, and / or have a basic-educational equivalent

Description

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.


Who this course is for:

  • Students looking for more opportunities to practice using the Python programming language
  • Enthusiasts wanting to create & manage complex graphical objects
  • Scientists looking to use Python on a classic Cartesian coordinate system
  • Software developers who need to respond to input events from application users
  • Scientists & engineers who need to simulate real-world operations using timed events
  • Students who need create in-progress views of operations across a time-series
  • Engineers who need to manage events between multiple object instances
  • Engineers needing to use pixel-relative distances, as well as object-heading, calculations
  • Software developers who need to graphically gather input from application users
  • Application developers who need to manage view-ports, scailing-factors, and create advanced presentations
  • Student needing an efficent way to record, tally, and / or "undo" pre-recorded graphical operations
  • Student looking for additional opportunities to practice Modern Python