Use Python turtle to make circles wtihout the circle function

Question

I have this assignment for school:

Build a Snowman without turtle circle function

The snowman should be on a blue background, and should be drawn filled with white.

The outline of the snowman should be in black.

The snowman’s body should be made of 3 filled circles.

The outline of each circle should be 3 pixels wide.

The bottom circle should have a radius of 100 pixels.

The middle circle should have a radius of 70 pixels.

The top circle should have a radius of 40 pixels.

Each circle should be centered above the one below it (except the bottom circle, which can be located anywhere).

There should be no gap between the circles.

Give the snowman a mouth, eyes, and a nose (a hat is optional).

Make sure to include two stick-arms and at least two fingers on each hand.

So far I created this, but I can't seem to get the circles right before I move on. Also, don't know how to color in circles or make dots for eyes. Help me please, first time coding.

import turtle                               # allows us to use turtle library
wn = turtle.Screen()                        # allows us to create a graphics window
wn.bgcolor("blue")                          # sets gtaphics windows background color to blue
import math                                 # allows us to use math functions
quinn = turtle.Turtle()                     # sets up turtle quinn
quinn.setpos(0,0)
quinn.pensize(3)
quinn.up()

# drawing first circle middle
quinn.forward(70)
quinn.down()
quinn.left(90)

# calculation of cicumference of a circle
a = (math.pi*140.00/360)

#itineration for first circle
for i in range (1,361,1):
    quinn.left(a)
    quinn.forward (1)

# drawing second circle bottom
quinn.up()
quinn.home()
quinn.right(90)
quinn.forward(70)
quinn.left(90)
quinn.down()

b = (math.pi*200.00/360)

for i in range (1,361,1):
    quinn.right(b)
    quinn.forward(1)

# drawing third circle head top

quinn.up ()
quinn.goto(0,70)
quinn.right(90)
quinn.down()

c =(math.pi*80/360)

for i in range (1,361,1):
    quinn.left(c)
    quinn.forward(1)

wn.exitonclick()

Answer 1

The following is an example function to draw a circle filled in blue:

def draw_circle(radius):    
    turtle.up()
    turtle.goto(0,radius) # go to (0, radius)
    turtle.begin_fill() # start fill
    turtle.down() # pen down
    turtle.color('blue')
    times_y_crossed = 0
    x_sign = 1.0
    while times_y_crossed <= 1:
        turtle.forward(2*math.pi*radius/360.0) # move by 1/360
        turtle.right(1.0)
        x_sign_new = math.copysign(1, turtle.xcor())        
        if(x_sign_new != x_sign):
            times_y_crossed += 1
        x_sign = x_sign_new
    turtle.up() # pen up
    turtle.end_fill() # end fill.
    return

Then you can modify the above function adding parameters for position (x,y) of the circle center:

def draw_circle(radius, x, y):    
    turtle.up()
    turtle.goto(x,y+radius) # go to (x, y + radius)
    turtle.begin_fill() # start fill
    turtle.down() # pen down
    turtle.color('blue')
    times_y_crossed = 0
    x_sign = 1.0
    while times_y_crossed <= 1:
        turtle.forward(2*math.pi*radius/360.0) # move by 1/360
        turtle.right(1.0)
        x_sign_new = math.copysign(1, turtle.xcor())        
        if(x_sign_new != x_sign):
            times_y_crossed += 1
        x_sign = x_sign_new
    turtle.up() # pen up
    turtle.end_fill() # end fill.
    return

You can easily add dots as, for instance,:

turtle.goto(-20,10)
turtle.color('red')
turtle.dot(20)
turtle.goto(40,10)
turtle.dot(20)

Putting together:

import turtle
import math

def draw_circle(radius, x, y):    
    turtle.up()
    turtle.goto(x,y+radius) # go to (0, radius)
    turtle.begin_fill() # start fill
    turtle.down() # pen down
    turtle.color('blue')
    times_y_crossed = 0
    x_sign = 1.0
    while times_y_crossed <= 1:
        turtle.forward(2*math.pi*radius/360.0) # move by 1/360
        turtle.right(1.0)
        x_sign_new = math.copysign(1, turtle.xcor())        
        if(x_sign_new != x_sign):
            times_y_crossed += 1
        x_sign = x_sign_new
    turtle.up() # pen up
    turtle.end_fill() # end fill.
    return


draw_circle(100, 10, 10)
turtle.goto(-20,10)
turtle.color('red')
turtle.dot(20)
turtle.goto(40,10)
turtle.dot(20)
turtle.pen(shown=False)
turtle.done()

You should attempt to do by yourself the remaining part of the assignment.. ;)

Answer 2

Sorry for not giving an explanation. The first part is Ramanujan's aproximation of pi, but not a very good one because it only reaches an aproximation of pi after something like 300,000 iterations of the loop and it is only accurate to 5 decimal places. that would be this part:

    r += (1 / k) * (-1)**i
    pi = (4 * (1 - r))

Then I use the circumference of a circle:

t.forward(2*5*pi)

Finally I just make the turtle walk clock wise by 20.

import turtle 
t = turtle.Turtle()
t.right(90)
t.penup()
t.goto(100, 0)
t.pendown()

i = 0
r = 0
k = 3

while i <= 360:
    r += (1 / k) * (-1)**i
    pi = (4 * (1 - r))
    t.write(pi)
    t.forward(2*5*pi)
    t.right(20)

    i += 1
    k += 2

turtle.done()

Answer 3

Most solutions to "without turtle circle function" involve writing your own equivalent to turtle's circle function. But there are already two other ways you can draw outlined, filled circles with turtle.

One is you can use concentric dots:

turtle.color('black')
turtle.dot(200 + 3)
turtle.color('white')
turtle.dot(200 - 3)

Just remember that dot() takes a diameter whereas circle() takes a radius:

However, I prefer to use stamping to solve these sorts of problems:

''' Build a Snowman without turtle circle function '''

from turtle import Turtle, Screen

# The snowman’s body should be made of 3 filled circles.

# The bottom circle should have a radius of 100 pixels.
# The middle circle should have a radius of 70 pixels.
# The top circle should have a radius of 40 pixels.

RADII = (100, 70, 40)

STAMP_SIZE = 20

# The snowman should be on a blue background
screen = Screen()
screen.bgcolor('blue')

quinn = Turtle('circle')
quinn.setheading(90)
quinn.up()

# The outline of the snowman should be in black, and should be drawn filled with white.
quinn.color('black', 'white')

for not_first, radius in enumerate(RADII):

    if not_first:
        quinn.forward(radius)

    # The outline of each circle should be 3 pixels wide.
    quinn.shapesize((radius * 2) / STAMP_SIZE, outline=3)

    quinn.stamp()

    # Each circle should be centered above the one below it
    # There should be no gap between the circles.
    quinn.forward(radius)

# Give the snowman eyes

quinn.shapesize(15 / STAMP_SIZE)
quinn.color('black')
quinn.backward(3 * RADII[-1] / 4)

for x in (-RADII[-1] / 3, RADII[-1] / 3):
    quinn.setx(x)
    quinn.stamp()

# Give the snowman a mouth, and a nose (a hat is optional).

pass

# Make sure to include two stick-arms and at least two fingers on each hand.

pass

quinn.hideturtle()

screen.exitonclick()

The idea is you contort the turtle cursor itself to what you need, make a snapshot of it on the screen, and then contort it to the next thing you need to draw.

Answer 4

From a mathematical standpoint, you can use functions sin and cos from the math to plot the circle.

Once the circle is plot, use the turtle.begin_fill() and turtle.end_fill() methods to fill in the circle (though I do agree that in programming, this method is more practical):

from turtle import Turtle
from math import sin, cos, radians

def draw_circle(radius, x, y, color="light blue", line_width=3):
    c = Turtle(visible=False)
    c.width(3)
    c.penup()
    c.goto(x + radius, y)
    c.pendown()
    c.color("black", color)
    c.begin_fill()
    # Circle drawing starts here
    for i in range(1, 361):
        c.goto(radius * cos(radians(i)) + x,
               radius * sin(radians(i)) + y)
    # Circle drawing ends here
    c.end_fill()
draw_circle(100, 0, -100)

---

As pointed out in this answer, you can use the turtle.dot() method to draw a dot on the screen, and the width of the pen will be the diameter of the dot.

There's another way to do that, but compared to the dot method, it is impractical. I'll throw it out there anyway, just to show how there are many possibilities in workarounds:

from turtle import Turtle

def draw_circle(radius, x, y, color="light bue", line_width=3):
    c = Turtle(visible=False)
    c.penup()
    c.goto(x, y)
    c.pendown()
    # Circle drawing starts here
    c.width(radius * 2 + line_width)
    c.forward(0)
    c.color(color)
    c.width(radius * 2 - line_width)
    c.forward(0)
    # Circle drawing ends here

draw_circle(100, 0, -100)

So a turtle.dot() is the equivalent of turtle.forward(0) (and turtle.backward(0), turtle.goto(turtle.pos()), turtle.setpos(turtle.pos()), etc., etc.).

Output:

Answer 5

You can create a function that takes arguments fd, and left.

here is what I created.

from turtle import *
speed(100000)
for i in range(360):
    fd(2)
    left(1)

Here is the calculation: The iterations in range divided by the fd+left. That is the approximation I have. SO you should be able to create a function like that.

Answer 6

You could try this, hope this helps!

def polygon(length, sides):
    for i in range(sides):
        turtle.forward(length)
        turtle.left(360.0/sides)

polygon(1, 360)