1. Com a rotina do polígono (ou quadrado), crie um código com (for _ in range (10) ) que desenhe 10 quadrados no canvas, variando a posição de cada quadrado (usando os comandos goto(), up(), e down()). Use random. randint() para sortear números aleatórios para a posição inicial e para o tamanho do lado do quadrado.

Passo 1

O enunciado pede que eu crie um código que desenhe 10 quadrados no canvas usando uma rotina de polígono (ou quadrado), repetindo a operação com um laço for _ in range(10). Cada quadrado deve ter posição inicial sorteada aleatoriamente e tamanho do lado sorteado aleatoriamente, e devo usar os comandos goto(), up() e down() para posicionar a tartaruga antes de desenhar. Também devo usar random.randint() para gerar os números aleatórios.
Informações relevantes que o enunciado dá:
  • Devem ser desenhados exatamente 10 quadrados (usar for _ in range(10)).
  • A posição inicial de cada quadrado deve ser sorteada (usar random.randint()).
  • O tamanho do lado de cada quadrado deve ser sorteado (usar random.randint()).
  • Para posicionamento, usar goto(), up() e down() (ou seja: mover sem desenhar, posicionar, e então desenhar).
  • Posso usar a rotina do polígono (uma função que desenha um quadrado dado o tamanho do lado).

Passo 2

Vamos entender as ferramentas que vamos usar (pequena “aula” prática):
  • O módulo turtle permite desenhar movendo uma “tartaruga” na tela. Importamos com import turtle.
  • up() é sinônimo de penup() — levanta a caneta para mover sem desenhar. down() é sinônimo de pendown() — abaixa a caneta para começar a desenhar.
  • goto(x, y) move a tartaruga para a coordenada (x,y) na tela. A tela do turtle usa coordenadas cartesianas com o centro em (0,0).
  • setheading(angle) orienta a tartaruga para um ângulo (0 aponta para a direita, 90 para cima, etc.). Usar isso garante que o quadrado sempre saia orientado do mesmo jeito.
  • random.randint(a, b) retorna um inteiro aleatório entre a e b inclusive. Precisamos importar random para usar isso.
  • Laço for _ in range(10): repete um bloco 10 vezes. Usamos _ quando não precisamos do índice.
Dica prática: escolher limites coerentes para x, y e lado evita que os quadrados caiam fora da área visível. Podemos ajustar a tela com screen.setup(width, height) e escolher limites relativos a isso.

Passo 3

Vamos escrever a função que desenha um quadrado a partir da posição atual da tartaruga. Explico passo a passo:
  • Objetivo da função: receber lado (tamanho do lado) e desenhar um quadrado sem mover a tartaruga para outro ponto além do perímetro do quadrado.
  • Como desenhar um quadrado com turtle: repetimos 4 vezes: avançar lado e girar 90 graus à esquerda (ou à direita).
  • Em Python, a função fica assim:
def draw_square(t, lado):
    for _ in range(4):
        t.forward(lado)
        t.left(90)
Explicação das variáveis:
  • t é o objeto tartaruga (ex.: t = turtle.Turtle()), assim evitamos usar a tartaruga global diretamente e mantemos o código organizado.
  • lado é um inteiro que representa o comprimento do lado do quadrado em pixels.

Passo 4

Escolher ranges (limites) razoáveis para posições e tamanhos:
  • Vou configurar a tela para 800x600 pixels com screen.setup(800, 600). Assim, as coordenadas visíveis em x vão aproximadamente de -400 a 400 e em y de -300 a 300.
  • Para evitar que um quadrado de tamanho lado saia totalmente da tela quando posicionado com a tartaruga no canto superior esquerdo do quadrado, escolho limitar x e y de forma que sobrem lado pixels até as bordas. Uma forma simples (e suficiente para prova) é sortear x em [-350, 350] e y em [-250, 250] e o lado em [20, 150]. Esses valores mantêm a maioria dos quadrados visíveis. Se quiser garantias formais, dá para calcular margens a partir do lado, mas isso complica sem necessidade.

Passo 5

Agora montamos o laço principal que repete 10 vezes:
  • Em cada iteração:
    1. Geramos x = random.randint(-350, 350) e y = random.randint(-250, 250).
    2. Geramos lado = random.randint(20, 150).
    3. Levantamos a caneta com t.up().
    4. Vamos para a posição com t.goto(x, y).
    5. Garantimos orientação com t.setheading(0) para quadrados sempre alinhados da mesma forma.
    6. Abaixamos a caneta com t.down().
    7. Chamamos draw_square(t, lado) para desenhar o quadrado.
  • Usamos for _ in range(10): conforme pedido.

Passo 6

Outras recomendações práticas para deixar o desenho legal e rápido:
  • Usar t.speed('fastest') para acelerar o desenho.
  • Usar t.hideturtle() para não mostrar a tartaruga enquanto desenha.
  • Opcional: variar a cor com t.color(...) ou preencher com begin_fill() / end_fill() para ficar mais visual.
  • Ao final, chamar turtle.done() para manter a janela aberta até você fechar.

Passo 7

Aqui está o código completo pronto para rodar — é o resultado pedido. Ele usa exatamente for _ in range(10), goto(), up() e down(), e random.randint() para posição e tamanho:

Resposta

import turtle
import random

# Configuração da tela
screen = turtle.Screen()
screen.setup(800, 600)

# Cria a tartaruga
t = turtle.Turtle()
t.speed('fastest')
t.hideturtle()

def draw_square(t, lado):
    for _ in range(4):
        t.forward(lado)
        t.left(90)

# Laço para desenhar 10 quadrados
for _ in range(10):
    x = random.randint(-350, 350)
    y = random.randint(-250, 250)
    lado = random.randint(20, 150)

    t.up()            # levanta a caneta (não desenha ao mover)
    t.goto(x, y)      # posiciona a tartaruga na posição inicial sorteada
    t.setheading(0)   # garante orientação padrão (apontando para a direita)
    t.down()          # abaixa a caneta (pronto para desenhar)

    draw_square(t, lado)

turtle.done()

Exercícios relacionados