Forem: taarimalta

azure

taarimalta — Sat, 14 Mar 2026 02:08:13 +0000

QuizPlay - play certification quizzes straight from GitHub

taarimalta — Fri, 13 Mar 2026 17:35:15 +0000

After taking AZ-204, AZ-104, and AZ-305, I realized that while Microsoft Learn is free, it's not enough to pass. You need practice and practice costs money.

The paid platforms want $30-$50/month. The free ones are mostly outdated multiple choice questions with no explanations. And none of them have the question types you actually get on the exam - case studies with tabbed reference material, hotspot images where you click on a diagram, drag-and-drop ordering, fill-in-the-blank dropdowns.

So I built QuizPlay. Think of it like a music player, but for quizzes.

How it works

You point it at a GitHub repo that has quiz questions and it plays them. No backend, no account, no database. It runs entirely in your browser.

It supports seven question types:

Single and multiple choice
Ordering (drag items into the correct sequence)
Hotspot (click on the correct region of a diagram)
Hotspot-dropdown (dropdown menus on image zones)
Matching (pair items to slots)
Fill-in-the-blank (complete statements using dropdowns)
Case studies (tabbed reference scenarios with linked questions)

That last one is the big one. Real Azure exams give you a case study with tabs - company overview, business goals, network diagram - and then ask you questions about it. I haven't seen a free practice tool do that

Here's what the quiz player looks like with a case study question:

You get a timer, mark-for-review, a question navigator and detailed explanations after every question

Quizzes live in GitHub repos

This is the part I'm most happy about. Quiz content doesn't live in the app. It lives in GitHub repos

Each quiz is just a repo with this structure:

my-quiz/
├── quiz.json          # manifest
├── questions/         # individual question JSON files
├── scenarios/         # optional case study files
├── assets/images/     # diagrams, exhibits
└── README.md

The player fetches the manifest, loads the questions, renders them. No API keys, no admin panel

The quiz content repos on quizplay-io are all open - you can fork them, improve them, submit PRs for corrections, or use them as a starting point for your own. The player app itself is not open source but all the content that feeds into it is

What questions look like

Each question is a JSON file. Let's look at a few

A single-choice question:

{
  "id": "q-001",
  "type": "single",
  "question": "What does HTML stand for?",
  "options": [
    { "text": "Hyper Text Markup Language", "correct": true },
    { "text": "High Tech Modern Language" },
    { "text": "Hyper Transfer Markup Language" }
  ],
  "explanation": "HTML stands for **Hyper Text Markup Language**."
}

The explanation field supports Markdown so you can use code blocks, links, images etc

A hotspot question has zones defined as percentages of the image dimensions:

{
  "type": "hotspot",
  "question": "Click on the Load Balancer in the diagram.",
  "image": "assets/images/architecture.png",
  "zones": [
    { "x": 10, "y": 5, "width": 25, "height": 20, "label": "Load Balancer" },
    { "x": 40, "y": 30, "width": 20, "height": 25, "label": "Web Server" },
    { "x": 70, "y": 50, "width": 20, "height": 20, "label": "Database" }
  ],
  "correctZone": 0
}

And a case study question references a shared scenario file:

{
  "caseStudy": "scenarios/cloud-migration.json",
  "question": "Which service meets Contoso's HA requirement?",
  "options": [
    { "text": "Azure Traffic Manager", "correct": true },
    { "text": "Azure Load Balancer" },
    { "text": "Azure Application Gateway" }
  ]
}

The scenario file has tabs just like the real exam:

{
  "tabs": [
    { "title": "Overview", "content": "Contoso Ltd is migrating to Azure..." },
    { "title": "Requirements", "content": "- High availability across two regions\n- Budget: $5,000/month" }
  ]
}

Multiple questions can share the same scenario

How to create your own quiz

The fastest way is to fork the sample quiz repo. It has working examples of every question type

Edit quiz.json with your quiz info:

{
  "title": "Your Quiz Title",
  "description": "A short description for the quiz card.",
  "category": "Your Topic",
  "questions": [
    "questions/01-your-first-question.json",
    "questions/02-your-second-question.json"
  ]
}

Replace the sample questions in questions/ with your own

If you don't want to write questions by hand, the sample repo also includes a quiz-folder-creation-prompt.md that you can paste into Claude or any AI assistant. It'll generate a full set of 36 questions with case studies, correct question type distribution, proper JSON schemas and fictional company names. The official AZ quiz sets were all created this way

One thing I want to be clear about - these are not exam dumps. None of the questions are copied from real exams. The AI prompt is specifically designed to generate original questions based on the exam objectives, using fictional company names. I wanted to keep this legal and useful for actual learning, not just memorization of leaked answers

You can test locally before publishing - go to quizplay.io, click the folder icon and select your quiz folder from your computer

When you're ready, add the quizplay topic to your repo on GitHub (gear icon next to "About" on your repo page). That's it. QuizPlay discovers repos via GitHub's topic search so your quiz shows up in the Community Quizzes tab automatically. No pull request, no approval needed

Quizzes can be about anything - Azure, AWS, programming languages, history, science, whatever you want. People have already contributed an AWS SAA-C03 set and a PL-400 (Power Platform Developer) set

Current official quizzes

The quizplay-io org hosts practice sets for:

There's also a JavaScript Fundamentals sample quiz that demonstrates all seven question types - useful as a reference if you're building your own

Give it a try at quizplay.io. And if you make a quiz, tag it with quizplay - I'd love to see what people come up with!

All Star Polygons with Python Turtle

taarimalta — Fri, 18 Jun 2021 17:54:19 +0000

In the previous article we showed how to draw a regular star polygon which was not degenerate i.e it could be drawn without lifting the pen from the paper. In this one we will attempt to come up with a way to draw two types star polygons.

By two types I mean degenerate (must lift pen) and non-degenerate/regular (no lift pen) but I don't know the true names of these star polygons types. But I hope I get the idea across

Repeated regular polygon method

In this method we are going to look at how to draw a degenerate star polygon by repeatedly drawing regular polygon polygons (like triangles, squares and pentagons)

The Star of David

Let's begin with the simplest degenerate star we know of the Star of David. This type of star can be draw by simply drawing one equilateral triangle and then overlapping it with another one which is upside down

Note that you can draw a triangle using the circle function! See the code below

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

t.circle(LENGTH)
t.circle(LENGTH,steps=3)
t.circle(LENGTH,steps=4)
t.circle(LENGTH,steps=5)

In the code above, we are drawing a triangle, square and a pentagon inscribed within the same circle making use of the steps parameter. Here's what we get:

Now we know how to use the steps argument, we can use it twice from two different places on a circle to draw our star

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def star_of_david():
    """Draws two overlapping triangles
    """
    t.circle(LENGTH,steps=3)
    t.penup()
    t.circle(LENGTH, 180)
    t.pendown()
    t.circle(LENGTH,steps=3)

t.circle(LENGTH)
star_of_david()

In the code above t.circle(LENGTH, 180) makes the turtle go to the top of the circle so that it can draw another triangle from there. Here's what we get

Degenerate Octagram

You can draw a degenerate octagram using a similar method

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def degenerate_octagram():
    t.circle(LENGTH,steps=4)
    segments=8
    t.circle(LENGTH,360/segments)
    t.circle(LENGTH,steps=4)

t.circle(LENGTH)
degenerate_octagram()

After drawing the first square, we are moving the turtle to a location determined by 360 / segments. segments = 8 because an octagram has 8 equal segments.

Remember that a n-gram star has n equal segments

Degenerate enneagram

According to wikipedia, enneagram is a 9 pointed star. Unlike the hexagram and the decagram, the enneagram cannot be drawn with just two regular polygons. But how many do we need?

A degenerate enneagram should be drawn by using 3 equilateral triangles (You can try drawing this on a piece of paper too).

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def enneagram():
    segments=9

    t.circle(LENGTH, steps=3)
    t.circle(LENGTH, 360/segments)
    t.circle(LENGTH, steps=3)
    t.circle(LENGTH, 360/segments)
    t.circle(LENGTH, steps=3)

t.circle(LENGTH)
enneagram()

In the code above, we are calling the circle(LENGTH, steps=3 function 3 times

A General method - 1 (Regular non star Polygon based)

Now, how do we know the number of times we need to repeat the circle and step commands? To answer that we can make a few observations about the examples above:

A hexagram is a (6,2) star where the vertices - 6 is divisible the order- 2, 3 times
A octagram is a (8,2) star where the vertices - 8 is divisible the order- 2, 4 times
A enneagram is a (9,3) star where the vertices - 9 is divisible the order- 3, 3 times

With the above, we might be able to say that for a degenerate n-gram with the order m, the quotient of n/m is the number of sides of the polygon while the order m is the number of times we need to draw the polygon

So, we should try the following:

For an n,m degenerate star draw m number of regular polygons
And the polygons drawn should have n/m sides

Let's code that

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=200

def degenerate(n,m):
    segments = n
    order = m

    sides = int(n/m)

    for _ in range(order):
        t.circle(LENGTH, steps=sides)
        t.circle(LENGTH, 360/segments)

t.circle(LENGTH)
degenerate(10,2)

The code above works! It drew the 10 gram and the 12 grams below

(10,2)	(12,2)

You can also draw (12,3) and (12,4)

(12,3)	(12,4)

Interestingly if you try to draw (10,5) and (12,6) it draws this:

(10,5)	(12,6)

This is a reminder that the possible orders (values of m) are
2 through (n-1)/2-1. Basically the order can't be 1 and it also can't be half of the number of vertices

With the general code above, have we covered all the degenerate regular star polygons?

The (10,4) star

In the examples that we have looked at a degenerate star polygon can be composed of multiple regular (non-star) polygons. But (10,4) is a curious case. In the previous article we had written a code that draws regular stars. Let's see what happens when we use it here

import turtle as t

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

LENGTH=150

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)

regular_star(10,4)

Yes we get a pentagram! But we were supposed to have 10 vertices :(

A new type of degenerate

Hence, (10,4) is a new type of degenerate star where n is not divisible by m and as such we cannot draw it with the degenerate function we wrote earlier.

We can draw this type of degenerate stars by overlapping two stars. Unfortunately we cannot use the circle's step parameter anymore. We need to draw a regular star then rotate it to draw another star. To do that we will first begin by modifying our regular_star function as follows

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n

    t.left(180-angle/2)

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)

    t.right(180-angle/2)

The code above adds t.left(180-angle/2) to place the regular star to the left side of the turtle. This is similar to how a circle command behaves

Notice above that both the stars are drawn to the left side of the turtle

We will additionally make the following changes to our code

import turtle as t
import math

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

RADIUS=150


def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """

    angle = 360*m/n
    center_angle = 2*m*math.pi/n

    t.left(180-angle/2)


    length=2*RADIUS*math.sin(center_angle/2)

    for count in range(n):
       t.forward(length)
       t.right(angle)

    t.right(180-angle/2)

regular_star(7,2)
t.circle(RADIUS)

In the code above, we have made the following changes

Replaced the global LENGTH with RADIUS. This is to allow us to draw the star of a defined radius
Computed a center angle which is the angle subtended by m segments on the center of the circle. center_angle is the representation of arch length in radians
We used the center_angle and the RADIUS to compute the length of the arms of the star

(5,2)	(7,2)	(7,3)

We can now draw a star to the left side of the turtle having defined radius. We can even overlap them all

A better general method

Our goal is to build a better general method to draw any degenerate regular polygon star of a given number of vertices and order. Let's begin again by listing the properties of the degenerate stars

Star	Properties
(6,2)	2 overlapping triangles
(8,2)	2 overlapping squares
(9,3)	3 overlapping triangles
(10,4)	2 overlapping pentagrams
(14,4)	2 (7,2) stars
(14,6)	2 (7,3) stars
(15,6)	3 overlapping pentagrams

The above can be verified by trying them out on a piece of paper (or by just thinking way too hard)

Here's an algorithm that we might be able to use to draw all the of the above stars

Find the greatest common divisor (gcd) of n and m
Divide n and m by the gcd to obtain a star (n/gcd,m/gcd)
Draw the (n/gcd,m/gcd) star
Move the turtle to another position on the circumcircle determined by 360/n degrees
Repeat 3 until we have drawn the star gcd number of times

Let's try it:

import turtle as t
import math

t.shape('turtle')
t.color('#4F86F7')
t.pensize(2)

RADIUS=150

def regular_star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """
    angle = 360*m/n
    center_angle = 2*m*math.pi/n

    t.left(180-angle/2)

    length=2*RADIUS*math.sin(center_angle/2)

    for count in range(n):
       t.forward(length)
       t.right(angle)

    t.right(180-angle/2)


def star(n,m):
    """ n = number of pointies
        m = order of the star,
            (number of skips + 1)
    """
    gcd = math.gcd(n,m)
    new_n = int(n/gcd)
    new_m = int(m/gcd)
    segment_angle = 360/n

    for _ in range(gcd):
        regular_star(new_n, new_m)
        t.penup()
        t.circle(RADIUS, segment_angle)
        t.pendown()

star(10,4)

With the code above it turns out that when the gcd is 1, we get either a regular non-degenerate star or a polygon. So we have written code to generalize:

Regular Polygons
Regular Non-degenerate stars!
Regular degenerate stars!~
Weird stick star :)

Examples:

Name	Drawing
(10,1)
(10,2)
(10,3)
(10,4)
(10,5)
(14,4)
(14,6)
(15,6)

Bonus

You can overlap all orders for a fixed number of vertices to get beautiful images such as these

def all_stars(n):
    for x in range(int(n/2)):
        star(n,x+1)


all_stars(10)
t.hide()

Yay!!~

Regular Star Polygon with Python Turtle

taarimalta — Fri, 11 Jun 2021 18:30:04 +0000

If you are a doodler, you most certainly have doodled a pentagram or the Star of David at some point in your life.

Pentagram	Star of David

Maybe some of you have also tried to add more lines to draw even more complex stars. Did you know that these stars had names too?

Heptagram	Octagram

Anyways, I thought that it might be fun to try drawing these stars with Python. So let's begin drawing these polygons

A star is a polygon?

Turns out that the stars above are a class of polygons called complex polygons. Basically, as opposed to normal polygons, the lines intersect each other in complex polygons

A complex polygon	A complex polygon of star shape

The star polygon is a type of complex polygon. And there are two types. You must have realized that to draw the Star of David on a piece of paper, you have to lift your pen, but you don't have to do so to draw a pentagram. The former type of stars are called regular star polygons whereas the latter type are called degenerate star polygons

Regular octagram	Degenerate octagram

Rules of regular star polygons

As you may have noticed above, we can draw a star with a certain number of vertices in multiple ways. For example you can draw a star polygon with 9 vertices as follow:

Method 1	Method 2	Method 3

1 vertex skipped	2 vertices skiped	3 vertices skipped

To understand what's going on count the number of vertices skipped in each of the above diagrams. Also notice that when 2 vertices are skipped the star is degenerate whereas in the other cases the star is regular. You can try to skip more vertices but you will end up drawing the same stars.

Here are the rules and formulas which are going to be useful for us

For a star with N vertices you can draw abs(N/2)-1 stars

For example for a star with 9 vertices you can only draw abs(9/2)-1=3 stars
The order of a star M can be defined as the number of vertices skipped +1.

So the possible orders for a 9-vertex star are 2, 3 and 4 for 1, 2 and 3 vertices skipped respectively
If N is divisible by M, the star is degenerate

Exterior angle of a star

Before we trace the star we need to know the angles, specifically the exterior angles. This is to know how much to turn the turtle after each forward move. We will not be rigorously deriving a formula but will simply try to understand the following:

When the turtle starts at a point, goes around then returns, 360 degrees are turned in one full rotation always (also the reason why sum of exterior angles of a polygon = 360 degrees)
In case of a star, the turtle performs multiple full rotations
The number of rotations is equal to the order of the star - M
Therefore, the sum of exterior angles of a star is 360*M
Which means that for a regular star with N vertices each exterior angle = 360*M/N

Hope that's convincing enough

Enough talk let's draw

Now that we understand our favorite doodle, we are ready to code it in Python turtle. Notice that the angle of turn is set to what we just discussed

import turtle as t

LENGTH=500

def regular_star(n,m):
    """Draws a regular star polygon (not a degenerate one)
       n = number of pointies
       m = number of points to skip
    """

    angle = 360*m/n 

    for count in range(n):
       t.forward(LENGTH)
       t.right(angle)


t.hideturtle()
t.pensize(2)
t.color("green")

regular_star(103,51)

The above code only draws any regular star polygons (the one which can be drawn without lifting the pen). We will leave it to another post to draw a degenerate star

Here's a 103 pointed star

Yay!

Starry Night with Python Turtle

taarimalta — Fri, 04 Jun 2021 16:54:47 +0000

In the previous posts we did

In this article we will draw a night sky with a crescent moon. This will give us an opportunity to play with the random library of Python.

Set up the canvas

Let's set up the screen to a defined size and color it black like the dark of night.



import turtle as t

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000

t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")

We are setting up a square grid of coordinates

Generate stars

We can approximate stars by simply using white dots



import turtle as t

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="white"

t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")


t.penup()
t.color(STAR_COLOR, STAR_COLOR)

t.goto(100,100)
t.dot(1)
t.goto(20,20)
t.dot(2)
t.goto(-100, -10)
t.dot(1)
t.goto(10,-100)
t.dot(1)

t.hideturtle()

In the code above all we're doing is moving the turtle into different coordinates on the screen to plot dots.

Instead of manually defining the coordinates of the stars lets randomly generate them. Here's how we can do that



import random

for _ in range(1000)
    x = random.randint(-1000,1000)
    y = random.randint(-1000,1000)

    print(x,y)

This will print a series of coordinates which are pseudo-random

We will use the method above to generate the coordinates of the star. Here is the code



import turtle as t
import random

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="white"

t.Screen().tracer(0,0)
t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor("black")



def random_star():
  t.penup()
  t.color(STAR_COLOR, STAR_COLOR)

  x=random.randint(-SCREEN_WIDTH,SCREEN_WIDTH)
  y=random.randint(-SCREEN_HEIGHT,SCREEN_HEIGHT)

  dot_size=random.random()*3

  t.goto(x,y)
  t.dot(dot_size)


for _ in range(1000):
    random_star()

t.hideturtle()
t.Screen().update()

In the code above we have not only randomized the location of the stars but also the size of the stars (using dot). The size of the dot uses random.random()*3 instead of randint function. This gives us continuous random sizes as opposed to discreet.

Here is the result:

Now all we need is a moon

Draw a crescent moon

A direct approach to drawing a moon could be to draw a semicircle, then turn the turtle around and draw another arc to complete the loop. We will use an easier way where we don't have to compute the angles.

Here is the function that draws a moon



def moon(size=100):
  t.penup()
  t.left(20)

  t.color(MOON_COLOR, MOON_COLOR)
  t.dot(size)
  t.forward(size*.25)
  t.color(NIGHT_COLOR, NIGHT_COLOR)
  t.dot(size)

We are simply drawing a large white dot and then overlapping a large black dot on top of it.

One disadvantage of this approach is that some stars that are located outside the sphere of the moon are erased, but maybe no one will notice ;)

Here is the final code:



import turtle as t
import random

SCREEN_WIDTH=1000
SCREEN_HEIGHT=1000
STAR_COLOR="#f0ffff"
MOON_COLOR="#FFFFF0"
NIGHT_COLOR="black"

t.Screen().tracer(0,0)
t.Screen().screensize(SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().setworldcoordinates(-SCREEN_WIDTH,-SCREEN_HEIGHT,SCREEN_WIDTH,SCREEN_HEIGHT)
t.Screen().bgcolor(NIGHT_COLOR)

def moon(size=100):
  t.penup()
  t.left(20)

  t.color(MOON_COLOR, MOON_COLOR)
  t.dot(size)
  t.forward(size*.25)
  t.color(NIGHT_COLOR, NIGHT_COLOR)
  t.dot(size)

def random_star():
  t.penup()
  t.color(STAR_COLOR, STAR_COLOR)

  x=random.randint(-SCREEN_WIDTH,SCREEN_WIDTH)
  y=random.randint(-SCREEN_HEIGHT,SCREEN_HEIGHT)

  dot_size=random.random()*3

  t.goto(x,y)
  t.dot(dot_size)


for _ in range(1000):
    random_star()

moon(150)

t.hideturtle()
t.Screen().update()

Note that the location of the moon is going to be random too

Yay!!~~

Rainbow and Clouds with Python Turtle

taarimalta — Fri, 28 May 2021 15:53:34 +0000

In the previous posts we did

We will draw a rainbow with some clouds today. This one should be especially fun for kids because of the brights colors and the joyful objects that we will be drawing

Setting up the screen

To set up the stage let's first configure the height and the width of the canvas. We need the screensize command to set the size of the window, and the setworldcoordinates command to subdivide the window into the desired number of pixels. setworldcoordinates also sets up the coordinate axes for us



import turtle as t

t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)
t.Screen().bgcolor("lightblue")

We will be using a square grid. We have also set the color to lightblue using bgcolor

In the code above we have set the coordinate y-axis range to be within 300 and 900. This will make sense in the upcoming sections

We now have a blue sky

Draw a cloud

We will be using circles to draw a cloud but there could be multiple other ways to draw a cloud.

First start with a filled circle



import turtle as t
t.Screen().bgcolor("lightblue")

t.color("white","white")
t.begin_fill()
t.circle(50)
t.end_fill()

Now, lets put that code into a function



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

filled_circle(50,"white")

Filled circle function. Code does the same thing as before

Next we will draw multiple circles using the function above



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


radius = 50
cloud_color="white"

filled_circle(radius,cloud_color)
t.forward(radius)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)
filled_circle(radius,cloud_color)
t.right(90)

Multiple calls to filled_circle at different positions

We have a cloud now! ( Hope you think so too :) )



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


def cloud(radius, cloud_color="white"):
    filled_circle(radius,cloud_color)
    t.forward(radius)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)

radius = 50

cloud(radius)

cloud function for use later

Concentric circles

Let's work on the rainbow now. Our approach will be to use concentric filled circles to draw the rainbow. Let's see if we can get what we want by progressively reducing the radius of the filled_circle function.



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


filled_circle(100,'red')
filled_circle(95,'orange')
filled_circle(90,'yellow')
filled_circle(85,'green')
filled_circle(80,'blue')
filled_circle(75,'indigo')
filled_circle(70,'violet')

Reducing radius progressively and changing the color

We have a roygbiv but the circles are not concentric

Let's see how to make the circles above concentric. Let's also use a loop



import turtle as t
t.Screen().bgcolor("lightblue")

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']


radius=200
interval=10

for r_color in roygbiv:
    filled_circle(radius,r_color)
    radius -= interval

    # Move turtle a up by a little
    t.left(90)
    t.forward(interval)
    t.right(90)

In the code above we move the turtle up a little every time it completes a circle. We have also stored the colors of the rainbow in a list.

There are two additional things we should do. First, a rainbow could be circular but generally we see just a portion of the rainbow. To get that effect, we can move half the rainbow off the screen. Second, the center of the rainbow should be the sky. So let's make those adjustments



import turtle as t
t.Screen().bgcolor("lightblue")
t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


def rainbow(radius=200,interval=10):
    roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'lightblue']

    for r_color in roygbiv:
        filled_circle(radius,r_color)
        radius -= interval

        # Move turtle a up by a little
        t.left(90)
        t.forward(interval)
        t.right(90)


rainbow(300,10)

In the code above, we have changed the screen size and set up the coordinates such that only half the rainbow shows. Also, the rainbow code is now in a function. Lastly to show the center of the rainbow as the sky, lightblue has been added to the roygbiv variable

Putting it all together

We can now use the functions that we created to draw a rainbow amongst the clouds



import turtle as t
t.Screen().bgcolor("lightblue")
t.Screen().screensize(500,500)
t.Screen().setworldcoordinates(-300,300,300,900)
t.Screen().tracer(0,0)

def filled_circle(radius, color):
    t.color(color,color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()

def cloud(radius, cloud_color="white"):
    filled_circle(radius,cloud_color)
    t.forward(radius)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)
    filled_circle(radius,cloud_color)
    t.right(90)

def rainbow(radius=200,interval=10):
    roygbiv=['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'lightblue']

    for r_color in roygbiv:
        filled_circle(radius,r_color)
        radius -= interval

        # Move turtle a up by a little
        t.left(90)
        t.forward(interval)
        t.right(90)

t.penup()

t.goto(100,900)
cloud(20)
t.goto(-50,850)
cloud(30)
t.goto(50,600)
cloud(50)
t.goto(200,500)
cloud(5)

t.goto(0,0)
rainbow(300,10)

t.goto(-200,500)
cloud(15)
t.goto(50,400)
cloud(10)
t.goto(50,300)
cloud(10)

t.Screen().update()

Note that we have also added the t.Screen().tracer(0,0) and t.Screen().update() lines to speed up the drawing

And we get:

Yay!

How to draw a spiral with Python turtle

taarimalta — Sat, 22 May 2021 04:17:11 +0000

In the previous post , we learnt how to draw a filled star using Python turtle. In this article lets do a spiral because why not.

Circle

We can easily draw a circle using turtle.circle but we're going to draw it in a different way



import turtle as t

t.tracer(10,1)

for i in range(360):
 t.forward(1)
 t.right(1)


t.update()

In the code above, tracer and update commands are used to increase the drawing speed. We can remove them if we want.

The turtle moves a step forward then turns right by 1 degree. By the time the loop completes the turtle has turned by 360 degrees so has completed a full rotation and we get a circle

Increasing radius and rate of turn

Instead of moving at a constant distance what would happen if the turtle moves more on every iteration



for i in range(360):
 t.forward(i)
 t.right(1)

i replaces 1 as parameter to forward

We'll get something that quickly moves past the screen. Let's see if we can make it turn faster



for i in range(360):
 t.forward(i)
 t.right(20)

20 replaces 1 as parameter to right

Here's our spiral. But notice that the curve isn't smooth

Make the curve smoother

Let's see how we can make the spiral curve smoother. But first try out the following code



# Quadrant 1

t1 = t.Turtle()
t1.penup()
t1.goto(125, 125)
t1.pendown()
t1.circle(100)

# Quadrant 2

t2 = t.Turtle()
t2.penup()
t2.goto(-125, 125)
t2.pendown()
t2.circle(100, 270)

# Quadrant 3

t2 = t.Turtle()
t2.penup()
t2.goto(-125, -125)
t2.pendown()
t2.circle(100, 180)

# Quadrant 4

t3 = t.Turtle()
t3.penup()
t3.goto(125, -125)
t3.pendown()
t3.circle(100, 90)

Code prints 4 circle sections in 4 quadrants

We can use turtle's circle function to draw a portion of a circle. We can use this feature to make our turtle move in a smoother way along the spiral



import turtle as t

t.tracer(10,1)

for i in range(360):
 t.circle(i,20)

t.update()

forward and right function calls are replaced by circle

The circle function above moves the turtle forward but also turns by a certain angle. Here's what we get

We now have a smooth spiral!

Add more arms

But what if we wanted something that looks a little different - like a spiral galaxy or the milky way? We first need to add more arms.

To do this we're going to create multiple turtles



import turtle as t

t.tracer(10,1)

t1=t.Turtle()
t2=t.Turtle()
t1.setheading(0) # Looks to the right
t2.setheading(180) # Looks to the right

for x in range(360):
 radius = x
 angle = 1
 t1.circle(radius,angle)
 t2.circle(radius,angle)

t.update()

In the code above, t1 and t2 are two turtles that have been initially set to look to the right and to the left respectively using the setheading command

Both turtle have now started their own spiral in their own direction. Now let's see how to make this more configurable



import turtle as t
t.tracer(10,1)

N = 10
angle = 1

turtles = []
for position in range(N):
  look_at = 360/N*position
  new = t.Turtle()
  new.setheading(look_at)
  turtles.append(new)

for radius in range(360):
  for my in turtles:
    my.circle(radius, angle)


t.update()

We have simply changed the code such that any number of turtles can be created by changing N, and they all look towards different directions in a symmetric manner

Interestingly the spiral arms seem to intersect. We can prevent that from happening by making a few adjustments



import turtle as t

t.tracer(10,1)

N = 10
angle = 30

turtles = []
for position in range(N):
  look_at = 360/N*position
  new = t.Turtle()
  new.setheading(look_at)
  turtles.append(new)

for radius in range(360):
  for my in turtles:
    my.circle(radius*radius, angle)

t.update()

We set angle to 30 and we squared the radius

By making the angle of turn on each iteration larger and increasing the rate at which the spiral increases (by squaring the radius - radius*radius) we can prevent the spirals from intersecting. (Note that I found this out by accident)

Yayy!

How to draw a filled star with Python Turtle

taarimalta — Sat, 15 May 2021 07:48:32 +0000

I overdid things a little when trying to teach 6th graders how to draw a star using Python Turtle. But I thought that it was fun anyways so I'm sharing it here.

Note that this is also my first dev.to article. I appreciate any suggestion.

Start with a zig zag

A zig-zag can be simple to explain. We just have to move the cursor left then right over and over



import turtle as t

angle=150
side=100

angle_left=angle
angle_right=angle

t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)
t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)
t.forward(side)
t.right(angle_right)
t.forward(side)
t.left(angle_left)

Here's what we get

As we have repeating code we want to use a loop to reduce the code



import turtle as t

angle=150
side=100
pointies = 10

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)

Above we can change the value of pointies = 10 to change the number of zig zags

Rotate the zig zag

What happens if we rotate the zig zag by a certain value



import turtle as t

angle=150
side=100
pointies = 10
ROTATION = 30

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)

 t.right(ROTATION)

All we did above was added this statement t.right(ROTATION). We also said ROTATION = 30

and here's what we get

But wouldn't it be nice if the ends were connected? To achieve this we just need to set rotation to ROTATION = 360/pointies. Remember that 360 degrees is a full rotation.



import turtle as t

angle=150
side=100
pointies = 10
ROTATION = 360/pointies

angle_left=angle
angle_right=angle

for p in range(pointies):
 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)
 t.right(ROTATION)

The result:

Color the star

To color the star we first set the color using t.color("red","red"). We then use the begin_fill and end_fill commands to start and stop filling the area. Here's it is:



import turtle as t

t.speed(0)

angle=150
side=100
pointies = 10
ROTATION = 360/pointies

angle_left=angle
angle_right=angle

t.color("black","red")

t.begin_fill()

for p in range(pointies):


 t.forward(side)
 t.right(angle_right)
 t.forward(side)
 t.left(angle_left)
 t.right(ROTATION)

t.end_fill()

In the code above we have also added a statement t.speed(0) to speed things up

We can now draw stars with any number of points of any color. Here are some examples:

Rotate the star

Why stop at drawing a star when we can rotate it! To do this we use a nested for-loop. This means a loop inside a loop



import turtle as t

t.speed(0)
angle=150
side=100
pointies = 5
ROTATION = 360/pointies
angle_left=angle
angle_right=angle

t.color("red","black")

for r in range(10):

 t.begin_fill()
 for p in range(pointies):

  t.forward(side)
  t.right(angle_right)
  t.forward(side)
  t.left(angle_left)
  t.right(ROTATION)

 t.end_fill()

 t.right(2)

In the code above we added an extra loop that runs 10 times - for r in range(10):. We have also added a t.right(2) to the end of the loop to make the turtle rotate slightly everytime the inner loop completes

Check it out: