python: grille carrée simple

Votre principal problème est que vous tournez la tortue de 90 degrés vers la gauche après chaque carré. Cela signifie que vous allez simplement créer les 4 mêmes carrés encore et encore.

Au lieu de cela, vous devez avancer les unités de taille de la tortue et dessiner le carré suivant. Faites cela 20 fois; alors vous pouvez passer à la ligne suivante.

Pour cela, je vous suggère d'écrire une boucle pour dessiner une ligne. Ensuite, écrivez quelques lignes pour revenir au point de départ, mais en diminuant les unités de taille . Bouclez 20 fois ce processus.

Il y a plusieurs façons de dessiner une grille 20 x 20 avec Python, en voici quelques-unes:

En utilisant la tortue:

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()

En utilisant l'oreiller (PIL):

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()

Voici une approche intéressante que j'ai faite qui dessine des lignes puis des colonnes:

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)

Je pense que c'est plus amusant de regarder comme ça, plutôt que de faire un tas de carrés d'affilée. Évidemment, il pourrait être amélioré avec une taille carrée ajustable ...

Votre code a une paire de boucles imbriquées. Cependant, étant donné la façon dont vous dessinez la grille, vous avez vraiment besoin de trois boucles imbriquées. En essayant de trouver le moins de code à obtenir de l'endroit où vous êtes à l'endroit où vous voulez être, j'ai trouvé ce qui suit:

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()

Ce code est inefficace en termes de dessin, comme les lignes sont redessinées, ce qui est quelque chose à éviter. Ma solution préférée à ce problème est mon approche Tholian Web utilisant des générateurs:

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()

Mais c'est probablement exagéré pour vos besoins ...

Ceci est un code pour dessiner une grille simple en python de largeur, hauteur et nombre d'unités variables dans une grille.

#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()