How to Draw a Circle in Python?

The 'How to Draw a Circle in Python‘ blog explains how to draw circles in Python with this easy-to-follow step-by-step guide.

Drawing circles in Python is a valuable skill for beginners and experienced developers alike. In this guide, we'll break down the process of creating circles using different techniques, from built-in libraries like Matplotlib to manual calculations. Fear not if you're new to coding; we'll explain each step in simple terms, making the journey a breeze.

1. Using Built-in Libraries:

Python offers various built-in libraries that make drawing circles a breeze. One such library is Matplotlib, which is widely used for data visualization. With just a few lines of code, you can plot circles in different sizes and styles. Here's an example using Matplotlib:

import matplotlib.pyplot as plt

# Create a circle with a centre (0, 0) and a radius of 5
circle = plt.Circle((0, 0), 5, fill=False)

# Create a figure and axis
fig, ax = plt.subplots()

# Add the circle to the axis

# Set axis limits and show the plot
ax.set_xlim(-10, 10)
ax.set_ylim(-10, 10)
plt.axis('equal')  // To ensure the aspect ratio is maintained


  • We start by importing the matplotlib.pyplot module as plt, which allows us to create visualizations.
  • Using plt.Circle, we create a circle with a centre at (0, 0) and a radius of 5. The fill=False parameter ensures the circle is drawn as just an outline.
  • Next, we create a figure and axis using plt.subplots(). The figure serves as the canvas for our visualization, while the axis represents the coordinate system.
  • The circle is added to the axis using ax.add_patch(circle).
  • We set the limits for the x and y axes using ax.set_xlim() and ax.set_ylim(), respectively, to ensure the circle is visible on the plot.
  • Finally, we call plt.axis('equal') to maintain equal aspect ratios on both axes and show the plot using

2. Manual Calculation Method:

If you want to understand the math behind circle drawing, you can use Bresenham's Circle Drawing Algorithm. It's a fundamental method to plot precise circles without relying on libraries. Here's a simplified version of the algorithm:

def draw_circle(radius):
    x = 0
    y = radius
    d = 3 - 2 * radius

    while x <= y:
        // Plot the eight points of the circle using symmetry
        plot_points(x, y)
        if d < 0:
            d += 4 * x + 6
            d += 4 * (x - y) + 10
            y -= 1
        x += 1

def plot_points(x, y):
    // Plot points in all octants using symmetry
    points = [(x, y), (-x, y), (x, -y), (-x, -y),
              (y, x), (-y, x), (y, -x), (-y, -x)]
    for point in points:

def plot_pixel(point):
    // Draw a pixel at the given point (x, y)
    pass  // You can implement this function based on your chosen display method.


  • The draw_circle function takes the radius as an argument and implements Bresenham's algorithm to plot the circle.
  • We initialize x and y to 0 and radius, respectively, and d to 3 - 2 * radius. These variables represent the position and decision variables used in the algorithm.
  • The while loop runs until x is less than or equal to y.
  • Inside the loop, we call the plot_points function to plot the eight symmetrical points of the circle for each value of x and y.
  • The decision variable d is updated based on the algorithm rules to determine the next pixel position to plot.
  • The plot_points function takes (x, y) as input and plots the eight symmetrical points using the plot_pixel function.
  • The plot_pixel function is a placeholder that you need to implement based on your chosen display method (e.g., drawing pixels on a canvas or screen).

3. Turtle Method:

The Turtle graphics module in Python provides an interactive way to draw graphics. You can control a virtual turtle that moves around the screen and draws shapes. Here's an example of drawing a circle using the Turtle method:

import turtle

def draw_circle(radius):

// Set up the turtle
turtle.goto(0, -radius)

// Draw a circle with a radius of 50
radius = 50

// Close the turtle graphics window on click


  • We start by importing the turtle module, which provides a virtual turtle that can draw graphics on a canvas.
  • The draw_circle function takes the radius as an argument and uses the method to draw the circle with the specified radius.
  • The turtle.pendown() command places the turtle's pen down on the canvas, allowing it to draw when it moves.
  • After drawing the circle, we use turtle.penup() to lift the pen, so the turtle doesn't draw while moving to the next position.
  • We set up the turtle's speed using turtle.speed(1) to control the drawing speed.
  • The turtle's initial position is set using turtle.penup() and turtle.goto(0, -radius).
  • We call the draw_circle function with a radius of 50 to draw the circle.
  • Finally, turtle.exitonclick() keeps the turtle graphics window open until you click on it, allowing you to view the drawn circle.


In conclusion, drawing circles in Python can be achieved using built-in libraries like Matplotlib, manual calculation methods like Bresenham's algorithm, or interactive methods like Turtle Graphics. Each approach offers unique advantages and allows you to create beautiful visualizations and patterns. Experiment with these methods and explore the creative possibilities of circle drawing in Python!

You can also check these blogs:

  1. How to print a list in Python
  2. Get current year in Python
  3. Jaccard similarity in Python
  4. Python JSON Validator
  5. Python count unique values in column
  6. rstrip vs strip in Python: Trimming whitespaces made easy
  7. Python import class from another file
  8. Apply function to list in Python
  9. Dataframe to List in Python
  10. Get class name as string in Python