Drawing a pattern using turtle

Question

I am trying to draw a pattern of dots within a square. I have managed to draw the pattern, however there is a gap in the middle of the square (caused due to the inversion of the x coordinates). How can I correct this error? I have tried to invert the range (instead of the x coordinates), but python does not accept this format.

import turtle

T = turtle.Turtle()
turtle.tracer(0,0)
T.speed(10)
T.pensize(3)

zoom = 40 

def verticalSaddle2(T,n,k):
   for j in range(((n+1)//2),n+1):
          
    for i in range(1,(n+1)//2):
     
        if k <= 1 :
            return()

        else:
                        
                            T.penup()
                            T.setpos((j)* zoom, (i) * zoom)
                            T.pendown()
                            

                            T.dot(k)
                            k=k-2

    for i in range(((n+1)//2),n+1):
     
        if k <= 1 :
            return()
        else:
                        
                            T.penup()
                            T.setpos((j)* zoom, (i) * zoom)
                            T.pendown()
                            

                            T.dot(k)
                            k=k+2

 k=10
 n=7


 verticalSaddle2(T,n,k)

def verticalSaddle3(T,n,k):
for j in range(1,((n+1)//2)):
    
            for i in range(1,(n+1)//2):
             
                if k <= 1 :
                    return()

                else:
                                
                                    T.penup()
                                    T.setpos((-j)* zoom, (i) * zoom)
                                    T.pendown()
                                    

                                    T.dot(k)
                                    k=k-2

            for i in range(((n+1)//2),n+1):
             
                if k <= 1 :
                    return()
                else:
                                
                                    T.penup()
                                    T.setpos((-j)* zoom, (i) * zoom)
                                    T.pendown()
                                    

                                    T.dot(k)
                                    k=k+2
        
k=12
n=7
            
verticalSaddle3(T, n, k)

turtle.update()
turtle.done()

Answer 1

If you're trying to draw a dot painting of uniform circles filled into a square (ala Damien Hirst), here's the code. You can change the dimensions by changing the range function on the for loops accordingly. The colors are added at random, so you can ignore the colors, or just make them black, for the pattern.

import turtle as tim
from turtle import Screen
import random

tim.colormode(255)

color_list = [(25, 108, 164), (194, 38, 81), (238, 161, 49), (234, 215, 85), (226, 237, 228), (223, 137, 176),
              (144, 108, 56), (102, 197, 219), (206, 166, 29), (20, 57, 132), (214, 73, 90), (239, 89, 50),
              (141, 208, 227), (118, 192, 140), (3, 186, 176), (106, 107, 199), (138, 29, 73), (4, 161, 86),
              (98, 51, 36), (22, 156, 210), (232, 165, 184), (175, 185, 221), (29, 90, 95), (233, 172, 161),
              (152, 213, 190), (242, 205, 8), (89, 48, 31), (39, 46, 81), (26, 97, 94)]

tim.penup()


def dot_painting():
    count = 0
    for _ in range(10):
        for step in range(10):
            tim.dot(30, random.choice(color_list))
            tim.forward(35)
            if step == 9:
                count += 1
                if count % 2 != 0:
                    turn_left()
                else:
                    turn_right()


def turn_right():
    tim.dot(30, random.choice(color_list))
    tim.right(90)
    tim.forward(35)
    tim.right(90)


def turn_left():
    tim.dot(30, random.choice(color_list))
    tim.left(90)
    tim.forward(35)
    tim.left(90)


dot_painting()

screen = Screen()
screen.exitonclick()

Answer 2

One of your function draws left part of picture for negative x, another function almost same picture for right part for positive x, both parts are just mirrored versions of another part. x is handled by j loop. In order to draw same left and right picture without gap your both j loops should be fixed to be in same range, from 0 to (n+1)//2. Resulting fixed code below:

import turtle

T = turtle.Turtle()
turtle.tracer(0,0)
T.speed(0.01)
T.pensize(3)

zoom = 40 

def verticalSaddle2(T,n,k):
    for j in range(0,(n+1) // 2):
              
        for i in range(1,(n+1)//2):
         
            if k <= 1 :
                return()

            else:
                            
                T.penup()
                T.setpos((j)* zoom, (i) * zoom)
                T.pendown()
                

                T.dot(k)
                k=k-2

        for i in range(((n+1)//2),n+1):
         
            if k <= 1 :
                return()
            else:
                            
                T.penup()
                T.setpos((j)* zoom, (i) * zoom)
                T.pendown()
                

                T.dot(k)
                k=k+2

k=10
n=7


verticalSaddle2(T,n,k)

def verticalSaddle3(T,n,k):
    for j in range(0,((n+1)//2)):
        
        for i in range(1,(n+1)//2):
         
            if k <= 1 :
                return()

            else:
                            
                T.penup()
                T.setpos((-j)* zoom, (i) * zoom)
                T.pendown()
                

                T.dot(k)
                k=k-2

        for i in range(((n+1)//2),n+1):
         
            if k <= 1 :
                return()
            else:
                            
                T.penup()
                T.setpos((-j)* zoom, (i) * zoom)
                T.pendown()
                

                T.dot(k)
                k=k+2
        
k=12
n=7
            
verticalSaddle3(T, n, k)

turtle.update()
turtle.done()

Resulting image output below:

Your code can be simplified to have just one drawing function which draws x (j) in range from -(n + 1) / 2 to (n + 1) / 2. Simplified code is here .

It is possible to simplify even more to have very short code like next:

import turtle

T = turtle.Turtle()
turtle.tracer(0,0)
T.pensize(3)

zoom = 40 

def saddle(T, n, k):
    for j in range(-((n + 1) // 2) + 1, (n + 1) // 2):
        for i in range(1, n + 1):
            T.penup()
            T.setpos(j * zoom, i * zoom)
            T.pendown()
            T.dot(k - 2 * (min(i - 1, n - i) + (n + 1) // 2 - 1 - abs(j)))

saddle(T, 7, 16)

turtle.update()
turtle.done()

Answer 3

I believe you're making this problem more difficult than necessary. I would first get the code to simply draw a grid of uniform dots. Then modify the code to size the dots based on their position in the grid. Something like:

from turtle import Screen, Turtle

DISTANCE = 40

def saddle(t, n, minimum=1):
    assert n % 2 == 1, "n should be odd"

    t.penup()

    for x in range(-n // 2 + 1, n // 2 + 1):
        t.setx(x * DISTANCE)

        for y in range(-n // 2 + 1, n // 2 + 1):
            t.sety(y * DISTANCE)
            t.dot(2 * (minimum + abs(x) + abs(y)))

screen = Screen()
screen.tracer(False)

turtle = Turtle()
turtle.hideturtle()

saddle(turtle, 7)

screen.tracer(True)
screen.exitonclick()

I've made my code insist on an odd number for n, otherwise the pattern isn't symmetric.