python: простая квадратная сетка

В вашем коде есть пара вложенных циклов. Однако, учитывая способ рисования сетки, вам действительно нужны три вложенных цикла. Пытаясь вычислить наименьшее количество кода, чтобы добраться из того места, где вы находитесь, туда, где вы хотите быть, я придумал следующее:

from turtle import Screen, Turtle

def draw_square(turtle, size, num):
    for y in range(num):
        for x in range(num):
            for _ in range(4):
                turtle.forward(size)
                turtle.left(90)

            turtle.forward(size)

        parity = y % 2 == 0
        turn = turtle.left if parity else turtle.right

        turn(90)
        turtle.forward(size * 2 * parity)
        turn(90)

screen = Screen()

yertle = Turtle(visible=False)
yertle.speed('fastest')  # because I have no patience

draw_square(yertle, 25, 20)

screen.exitonclick()

Этот код неэффективен с точки зрения рисования, поскольку одни и те же линии перерисовываются, чего следует избегать. Мое личное любимое решение этой проблемы — мой подход Tholian Web с использованием генераторов:

from turtle import Turtle, Screen

UNIT_SIZE, GRID_SQUARES = 25, 20

GRID_SIZE = GRID_SQUARES * UNIT_SIZE

def half_grid(turtle):
    speed = turtle.speed()

    for brick in range(GRID_SQUARES):
        direction = [turtle.right, turtle.left][brick % 2 == 1]

        for _ in range(0, GRID_SIZE, speed):
            turtle.forward(speed)
            yield(0)

        direction(90)

        for _ in range(0, UNIT_SIZE, speed):
            turtle.forward(speed)
            yield(0)

        direction(90)

    for _ in range(0, GRID_SIZE, speed):
        turtle.forward(speed)
        yield(0)

heckle = Turtle(shape='arrow')
heckle.speed(5)  # speed needs to be a factor of UNIT_SIZE
heckle.penup()
heckle.goto(-GRID_SIZE / 2, -GRID_SIZE / 2)
heckle.pendown()
heckle.left(90)

jeckle = Turtle(shape='arrow')
jeckle.speed(5)
jeckle.penup()
jeckle.goto(GRID_SIZE / 2, -GRID_SIZE / 2)
jeckle.pendown()
jeckle.left(180)

generator1, generator2 = half_grid(heckle), half_grid(jeckle)

while (next(generator1, 1) + next(generator2, 1) < 2):
    pass

heckle.hideturtle()
jeckle.hideturtle()

screen = Screen()
screen.exitonclick()

Но это, вероятно, излишне для ваших целей...

Ваша главная проблема в том, что вы поворачиваете черепаху на 90 градусов влево после каждого квадрата. Это означает, что вы будете просто делать одни и те же 4 квадрата снова и снова.

Вместо этого вы должны продвинуть черепаху на size единиц и нарисовать следующий квадрат. Сделайте это 20 раз; тогда вы можете перейти к следующей строке.

Для этого я предлагаю вам написать цикл для рисования одной строки. Затем напишите несколько строк, чтобы вернуться к исходной точке, но вниз на size единицы. Зациклить этот процесс 20 раз.

Вот интересный подход, который я сделал, рисуя строки, а затем столбцы:

import turtle as tur


def make_grid(rows, columns):
    tur.color('black', 'white')
    tur.begin_fill()
    dir = 1
    tur.forward(20 * columns)
    for _ in range(rows):
        if dir > 0:
            tur.right(90)
            tur.forward(20)
            tur.right(90)
            tur.forward(20 * columns)
        else:
            tur.left(90)
            tur.forward(20)
            tur.left(90)
            tur.forward(20 * columns)
        dir *= -1
    tur.penup()
    tur.home()
    tur.pendown()
    tur.right(90)
    dir = 1
    tur.forward(20 * rows)
    for _ in range(columns):
        if dir > 0:
            tur.left(90)
            tur.forward(20)
            tur.left(90)
            tur.forward(20 * rows)
        else:
            tur.right(90)
            tur.forward(20)
            tur.right(90)
            tur.forward(20 * rows)
        dir *= -1
    tur.end_fill()
    tur.done()


make_grid(10, 10)

Я думаю, что так веселее смотреть, чем строить кучу квадратиков подряд. Очевидно, что его можно было бы улучшить с помощью регулируемого размера квадрата...

Есть несколько способов нарисовать сетку 20 x 20 с помощью Python, вот парочка:

Использование черепахи:

import turtle

def draw_box(t,x,y,size,fill_color):
    t.penup() # don't draw
    t.goto(x,y) # move to position
    t.pendown() # draw

    t.fillcolor(fill_color)
    t.begin_fill()  # set fill color

    for i in range(0,4):
        grid.forward(size) # move forward
        grid.right(90) # turn right 90 degrees

    t.end_fill()


def draw_grid():
    fill_color = 'white'
    start_x = -320 # starting x position of the grid
    start_y = -100 # starting y position of the grid
    box_size = 30 # pixel size of each square in the grid
    for i in range(0,20): # 20x20 grid
        for j in range(0,20):
            draw_box(grid,start_x+j*box_size,start_y+i*box_size,box_size,fill_color)


grid = turtle.Turtle()
draw_grid()
turtle.done()

Использование подушки (PIL):

from PIL import Image, ImageDraw

def main():
    steps = 25
    height = 600
    width = 600
    img = Image.new(mode='L', size=(height, width), color=255) # create blank image
    # img = Image.open('filename.png') # or load an image

    draw = ImageDraw.Draw(img)
    y_start = 0
    y_end = img.height
    step_size = int(img.width / steps)

    for x in range(0, img.width, step_size):
        line = ((x, y_start), (x, y_end))
        draw.line(line, fill='black')

    x_start = 0
    x_end = img.width

    for y in range(0, img.height, step_size):
        line = ((x_start, y), (x_end, y))
        draw.line(line, fill='black')

    del draw
    img.show()


if __name__ == '__main__':
    main()

Это код для рисования простой сетки в питоне с переменной шириной, высотой и количеством единиц в сетке.

#code to draw a grid
import turtle
import random
T= turtle.Turtle()
T.hideturtle()
turtle.tracer(0,0)





def draw_grid(num,width,height):
   n=num    # number of units in one column/row of a grid
   i=1
   for k in range (num):
       for j in range(num):

           for _ in range(2):
              turtle.forward(width*n)       #width of a unit of a grid
              turtle.left(90)
              turtle.forward(height*i)      #height of a unit of a grid
              turtle.left(90)
           i=i+1
        i=1
        n=n-1 


draw_grid(5,15,30)

turtle.update()
turtle.done()