Aula 08 - Desenhando com Código

🐢 Conhecendo a Tartaruga Mágica

O que é a Biblioteca Turtle?

A biblioteca Turtle é como ter uma tartaruga mágica que obedece aos nossos comandos para desenhar! É uma das formas mais divertidas de programar!

🤔 Por que se chama "Turtle"?

🐢

Analogia da Tartaruga:

Imagine uma tartaruga com uma caneta amarrada na cauda! Conforme ela se move, desenha uma linha. Nós programamos para onde ela vai!

🌟 Por que Usar Turtle Graphics?

👁️

Visual Imediato

Vemos nosso código funcionando na tela

🧮

Matemática Divertida

Aprender geometria brincando

🎨

Arte Criativa

Expressar criatividade através do código

🔄

Loops Visuais

Ver padrões e repetições em ação

📚 História Curiosa:

O Turtle Graphics foi criado em 1967 por Wally Feurzeig e Seymour Papert para ensinar programação para crianças! Eles queriam que aprender a programar fosse como brincar! 🎉

                        💡 Conceito-chave: Com Turtle Graphics, programar vira arte! Cada linha de código se transforma em traços coloridos na tela!
                    

🎨 Comandos Básicos da Tartaruga

Aprendendo a Controlar Nossa Tartaruga

Vamos descobrir todos os comandos para fazer nossa tartaruga criar desenhos incríveis!

📋 Categorias de Comandos:

🚶 Movimento:

forward(100)

Anda para frente 100 passos

backward(50)

Anda para trás 50 passos

right(90)

Vira 90 graus à direita

left(45)

Vira 45 graus à esquerda

✏️ Desenho:

pendown()

Abaixa a caneta (começa a desenhar)

penup()

Levanta a caneta (para de desenhar)

circle(50)

Desenha um círculo com raio 50

dot(20)

Faz um ponto com tamanho 20

🎨 Cores e Estilo:

color("red")

Muda cor da caneta para vermelho

fillcolor("blue")

Define cor de preenchimento azul

pensize(5)

Muda espessura da linha para 5

speed(0)

Define velocidade (0 = máxima)

📍 Posição:

goto(100, 50)

Vai para posição x=100, y=50

home()

Volta para o centro (0, 0)

setheading(0)

Define direção para 0 graus (Norte)

xcor(), ycor()

Mostra posição atual x e y

🧪 Testando os Comandos Básicos:

# Importando a biblioteca turtle
import turtle

# Criando nossa tartaruga
artista = turtle.Turtle()

print("🐢 TESTANDO COMANDOS BÁSICOS 🐢")

# 1. MOVIMENTO SIMPLES
print("1. Desenhando quadrado...")
for i in range(4):
    artista.forward(100)  # Anda 100 passos
    artista.right(90)     # Vira 90 graus

# 2. MUDANDO CORES
print("2. Testando cores...")
cores = ["red", "blue", "green", "yellow", "purple"]
for cor in cores:
    artista.color(cor)
    artista.circle(20)
    artista.penup()
    artista.forward(50)
    artista.pendown()

# 3. DIFERENTES ESPESSURAS
print("3. Diferentes espessuras...")
artista.home()  # Volta ao centro
for espessura in range(1, 6):
    artista.pensize(espessura)
    artista.forward(100)
    artista.backward(100)
    artista.right(36)  # 360/10 = 36 graus

# 4. FORMAS GEOMÉTRICAS
print("4. Formas geométricas...")
artista.home()
artista.pensize(3)
artista.color("orange")

# Triângulo
for i in range(3):
    artista.forward(80)
    artista.right(120)

# Ir para nova posição
artista.penup()
artista.goto(150, 0)
artista.pendown()

# Hexágono
artista.color("purple")
for i in range(6):
    artista.forward(60)
    artista.right(60)

print("✨ Teste completo!")
turtle.done()  # Manter janela aberta

📐 Sistema de Coordenadas:

🎯 Como Funciona:

Centro: (0, 0) - Meio da tela
X positivo: Direita
X negativo: Esquerda
Y positivo: Cima
Y negativo: Baixo
Ângulos: 0° = Norte, 90° = Leste

💡 Dica Importante:

Sempre teste comandos pequenos primeiro! É como aprender a dirigir - comece devagar e depois acelere! 🚗💨

🔁 Padrões e Repetições

Criando Arte com Loops

A verdadeira magia acontece quando combinamos loops com turtle graphics! Vamos criar padrões hipnotizantes!

🎭 Tipos de Padrões:

⭐ Padrão Estrela

import turtle

artista = turtle.Turtle()
artista.speed(0)
artista.color("gold")

# Estrela de 8 pontas
for i in range(8):
    artista.forward(100)
    artista.backward(100)
    artista.right(45)

turtle.done()

Desenha linhas do centro em todas as direções

🌸 Padrão Flor

import turtle

artista = turtle.Turtle()
artista.speed(0)

# Flor com 12 pétalas
for i in range(12):
    artista.color("pink")
    artista.circle(50)
    artista.right(30)

turtle.done()

Círculos repetidos em ângulos diferentes

🌀 Padrão Espiral

import turtle

artista = turtle.Turtle()
artista.speed(0)
artista.color("blue")

# Espiral crescente
for i in range(100):
    artista.forward(i)
    artista.right(91)

turtle.done()

Movimento crescente com virada ligeiramente diferente

🌈 Padrão Arco-íris

import turtle

artista = turtle.Turtle()
artista.speed(0)

cores = ["red", "orange", "yellow", "green", "blue", "purple"]

# Arco-íris de círculos
for i, cor in enumerate(cores):
    artista.color(cor)
    artista.circle(100 - i * 10)
    artista.penup()
    artista.goto(0, -10 * (i + 1))
    artista.pendown()

turtle.done()

Círculos concêntricos com cores diferentes

🚀 Padrões Avançados:

🎨 Arte Fractal Simples:

import turtle
import random

def arte_fractal():
    """Cria arte fractal colorida"""
    tela = turtle.Screen()
    tela.bgcolor("black")
    tela.setup(800, 600)
    
    artista = turtle.Turtle()
    artista.speed(0)
    artista.hideturtle()  # Esconde a tartaruga
    
    cores = ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FFEAA7", "#DDA0DD"]
    
    for i in range(200):
        # Escolhe cor aleatória
        artista.color(random.choice(cores))
        
        # Tamanho baseado na iteração
        tamanho = i * 2
        
        # Desenha círculo
        artista.circle(tamanho)
        
        # Vira um ângulo interessante
        artista.right(91)
        
        # Muda posição ligeiramente
        artista.forward(1)
    
    turtle.done()

# Executar
arte_fractal()

🔥 Mandala Automática:

import turtle
import math

def criar_mandala():
    """Cria uma mandala matemática"""
    tela = turtle.Screen()
    tela.bgcolor("black")
    
    artista = turtle.Turtle()
    artista.speed(0)
    artista.pensize(2)
    
    # Parâmetros da mandala
    num_circulos = 36
    raio_base = 100
    
    for i in range(num_circulos):
        # Calcula cor baseada no ângulo
        angulo = i * (360 / num_circulos)
        
        # Cores que mudam gradualmente
        red = int((math.sin(math.radians(angulo)) + 1) * 127.5)
        green = int((math.sin(math.radians(angulo + 120)) + 1) * 127.5)
        blue = int((math.sin(math.radians(angulo + 240)) + 1) * 127.5)
        
        # Define cor em formato hexadecimal
        cor = f"#{red:02x}{green:02x}{blue:02x}"
        artista.color(cor)
        
        # Desenha círculo
        artista.circle(raio_base)
        
        # Vira para próxima posição
        artista.right(360 / num_circulos)
    
    turtle.done()

# Executar
criar_mandala()

🎯 Dicas para Criar Padrões:

🔢 Experimente Ângulos:

91°, 89°, 137° criam padrões interessantes

📐 Use Matemática:

360 ÷ n = ângulo para n lados regulares

🎨 Combine Elementos:

Círculos + linhas + cores = magia

⚡ Ajuste Velocidade:

speed(0) para ver resultado rápido

🎨 Projeto Principal - Arte Generativa Completa

🚀 Criando um Gerador de Arte Automático!

Vamos construir um programa que cria arte única toda vez que executamos! Cada obra será uma surpresa!

🌟 Recursos do Nosso Gerador:

🎲

Aleatoriedade

Cores, tamanhos e posições aleatórias

🎨

Múltiplos Estilos

Geometric, orgânico, abstrato

💾

Salvar Obras

Guardar arte em arquivo

⚙️

Configurável

Usuário escolhe parâmetros

🎮 Código Completo - Gerador de Arte:

# 🎨 GERADOR DE ARTE GENERATIVA COMPLETO 🎨
import turtle
import random
import math
import time

class GeradorArte:
    """Classe para gerar arte automática com turtle"""
    
    def __init__(self):
        self.tela = turtle.Screen()
        self.artista = turtle.Turtle()
        self.configurar_ambiente()
    
    def configurar_ambiente(self):
        """Configura a tela e tartaruga"""
        self.tela.bgcolor("black")
        self.tela.setup(900, 700)
        self.tela.title("🎨 Gerador de Arte Generativa")
        
        self.artista.speed(0)
        self.artista.hideturtle()
        self.artista.pensize(2)
    
    def paleta_cores_aleatoria(self):
        """Gera uma paleta de cores harmoniosas"""
        paletas = [
            # Paleta Tropical
            ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FFEAA7"],
            # Paleta Noturna
            ["#2D3436", "#74B9FF", "#A29BFE", "#FD79A8", "#FDCB6E"],
            # Paleta Outono
            ["#E17055", "#FDCB6E", "#E84393", "#00B894", "#00CEC9"],
            # Paleta Primavera
            ["#FF7675", "#74B9FF", "#55A3FF", "#00B894", "#FDCB6E"],
            # Paleta Sunset
            ["#FD79A8", "#FDCB6E", "#E17055", "#74B9FF", "#A29BFE"]
        ]
        return random.choice(paletas)
    
    def arte_geometrica(self, complexidade=50):
        """Cria arte geométrica com formas regulares"""
        print("🔹 Gerando arte geométrica...")
        cores = self.paleta_cores_aleatoria()
        
        # Limpar tela
        self.artista.clear()
        
        for i in range(complexidade):
            # Escolher cor
            self.artista.color(random.choice(cores))
            
            # Posição aleatória
            x = random.randint(-400, 400)
            y = random.randint(-300, 300)
            self.artista.penup()
            self.artista.goto(x, y)
            self.artista.pendown()
            
            # Escolher forma
            forma = random.choice(['circulo', 'quadrado', 'triangulo', 'hexagono'])
            tamanho = random.randint(10, 80)
            
            if forma == 'circulo':
                self.artista.circle(tamanho)
            elif forma == 'quadrado':
                for _ in range(4):
                    self.artista.forward(tamanho)
                    self.artista.right(90)
            elif forma == 'triangulo':
                for _ in range(3):
                    self.artista.forward(tamanho)
                    self.artista.right(120)
            elif forma == 'hexagono':
                for _ in range(6):
                    self.artista.forward(tamanho // 2)
                    self.artista.right(60)
    
    def arte_organica(self, complexidade=100):
        """Cria arte orgânica com curvas e espirais"""
        print("🌿 Gerando arte orgânica...")
        cores = self.paleta_cores_aleatoria()
        
        self.artista.clear()
        
        for i in range(complexidade):
            self.artista.color(random.choice(cores))
            
            # Movimento orgânico
            self.artista.forward(random.randint(5, 50))
            self.artista.right(random.randint(-45, 45))
            
            # Ocasionalmente fazer curvas
            if random.random() < 0.3:
                raio = random.randint(10, 50)
                angulo = random.randint(90, 270)
                self.artista.circle(raio, angulo)
            
            # Ocasionalmente pular para nova posição
            if random.random() < 0.1:
                self.artista.penup()
                x = random.randint(-400, 400)
                y = random.randint(-300, 300)
                self.artista.goto(x, y)
                self.artista.pendown()
    
    def arte_fractal(self, profundidade=5):
        """Cria arte fractal com padrões recursivos"""
        print("🌀 Gerando arte fractal...")
        cores = self.paleta_cores_aleatoria()
        
        self.artista.clear()
        
        def desenhar_galho(tamanho, profundidade):
            """Desenha galho fractal recursivamente"""
            if profundidade == 0:
                return
            
            # Desenha linha principal
            self.artista.forward(tamanho)
            
            # Salva posição
            pos = self.artista.position()
            angulo = self.artista.heading()
            
            # Galho esquerdo
            self.artista.left(30)
            self.artista.color(random.choice(cores))
            desenhar_galho(tamanho * 0.7, profundidade - 1)
            
            # Volta à posição
            self.artista.penup()
            self.artista.goto(pos)
            self.artista.setheading(angulo)
            self.artista.pendown()
            
            # Galho direito
            self.artista.right(30)
            self.artista.color(random.choice(cores))
            desenhar_galho(tamanho * 0.7, profundidade - 1)
        
        # Posicionar na base
        self.artista.penup()
        self.artista.goto(0, -300)
        self.artista.setheading(90)
        self.artista.pendown()
        
        # Começar fractal
        self.artista.color(random.choice(cores))
        desenhar_galho(100, profundidade)
    
    def arte_mandala(self, detalhes=20):
        """Cria mandala matemática"""
        print("🕌 Gerando mandala...")
        cores = self.paleta_cores_aleatoria()
        
        self.artista.clear()
        self.artista.goto(0, 0)
        
        for camada in range(3):
            raio_base = 50 + camada * 40
            
            for i in range(detalhes):
                angulo = i * (360 / detalhes)
                
                # Cor gradual baseada no ângulo
                cor_index = int((i / detalhes) * len(cores))
                self.artista.color(cores[cor_index])
                
                # Desenha pétala
                self.artista.circle(raio_base, 60)
                self.artista.left(120)
                self.artista.circle(raio_base, 60)
                
                # Próxima posição
                self.artista.left(360 / detalhes - 120)
    
    def menu_principal(self):
        """Menu interativo para escolher tipo de arte"""
        while True:
            print("\n" + "🎨" * 30)
            print("    🎭 GERADOR DE ARTE GENERATIVA 🎭")
            print("🎨" * 30)
            print("\n📋 ESTILOS DISPONÍVEIS:")
            print("1. 🔹 Arte Geométrica")
            print("2. 🌿 Arte Orgânica") 
            print("3. 🌀 Arte Fractal")
            print("4. 🕌 Arte Mandala")
            print("5. 🎲 Surpresa (aleatório)")
            print("6. 🎬 Show Automático (todos os estilos)")
            print("7. 💾 Salvar Arte Atual")
            print("8. 🚪 Sair")
            
            try:
                escolha = int(input("\n🎯 Escolha um estilo (1-8): "))
                
                if escolha == 1:
                    complexidade = int(input("🔢 Complexidade (20-100): "))
                    self.arte_geometrica(complexidade)
                    
                elif escolha == 2:
                    complexidade = int(input("🔢 Complexidade (50-200): "))
                    self.arte_organica(complexidade)
                    
                elif escolha == 3:
                    profundidade = int(input("🔢 Profundidade (3-7): "))
                    self.arte_fractal(profundidade)
                    
                elif escolha == 4:
                    detalhes = int(input("🔢 Detalhes (10-30): "))
                    self.arte_mandala(detalhes)
                    
                elif escolha == 5:
                    print("🎲 Surpresa! Gerando arte aleatória...")
                    estilo = random.choice([1, 2, 3, 4])
                    if estilo == 1:
                        self.arte_geometrica(random.randint(30, 80))
                    elif estilo == 2:
                        self.arte_organica(random.randint(80, 150))
                    elif estilo == 3:
                        self.arte_fractal(random.randint(4, 6))
                    else:
                        self.arte_mandala(random.randint(15, 25))
                        
                elif escolha == 6:
                    print("🎬 Iniciando show automático...")
                    estilos = [
                        (self.arte_geometrica, [50]),
                        (self.arte_organica, [100]),
                        (self.arte_fractal, [5]),
                        (self.arte_mandala, [20])
                    ]
                    
                    for i, (func, args) in enumerate(estilos):
                        print(f"🎭 Exibindo estilo {i+1}/4...")
                        func(*args)
                        time.sleep(3)
                        
                elif escolha == 7:
                    nome = input("💾 Nome do arquivo (sem .ps): ")
                    try:
                        self.tela.getcanvas().postscript(file=f"{nome}.ps")
                        print(f"✅ Arte salva como {nome}.ps")
                    except:
                        print("❌ Erro ao salvar arquivo")
                        
                elif escolha == 8:
                    print("👋 Obrigado por usar o Gerador de Arte!")
                    break
                    
                else:
                    print("❌ Opção inválida! Escolha 1-8.")
                    
            except ValueError:
                print("❌ Digite apenas números!")
            except Exception as e:
                print(f"❌ Erro: {e}")
    
    def iniciar(self):
        """Inicia o gerador de arte"""
        print("🎊 Bem-vindo ao Gerador de Arte Generativa!")
        print("✨ Cada execução cria uma obra única!")
        self.menu_principal()
        turtle.done()

# Executar o programa
if __name__ == "__main__":
    gerador = GeradorArte()
    gerador.iniciar()

🚀 Extensões Possíveis:

🎵 Arte Musical

Sincronizar desenhos com música

📱 Interface Gráfica

Botões para controlar em tempo real

🌐 Arte Interativa

Responder a cliques do mouse

🎨 Mais Estilos

Pixel art, arte ASCII, 3D

💡 Conceitos Aplicados:

Classes e Objetos: Organização orientada a objetos
Métodos: Funções dentro de classes
Recursão: Funções que chamam a si mesmas
Aleatoriedade: Arte generativa única
Matemática: Ângulos, coordenadas, proporções

🏠 Desafios para Casa

🏠 Desafio Principal: Desenhe Sua Casa dos Sonhos

Use todos os comandos Turtle para criar a casa dos seus sonhos! Seja criativo!

🏗️ Elementos Obrigatórios:

🏠 Estrutura básica (paredes, teto)
🚪 Porta de entrada
🪟 Pelo menos 3 janelas
🌳 Árvore ou jardim
☀️ Sol ou nuvens no céu
🌈 Pelo menos 5 cores diferentes
🎨 Um elemento surpresa criativo

🏗️ Estrutura Base da Casa:

import turtle
import random

def desenhar_casa():
    """Desenha uma casa completa"""
    # Configuração inicial
    tela = turtle.Screen()
    tela.bgcolor("lightblue")  # Céu azul
    tela.setup(900, 700)
    
    arquiteto = turtle.Turtle()
    arquiteto.speed(5)
    arquiteto.pensize(3)
    
    # 1. ESTRUTURA PRINCIPAL
    def desenhar_paredes():
        """Desenha as paredes da casa"""
        arquiteto.color("brown")
        arquiteto.fillcolor("beige")
        arquiteto.begin_fill()
        
        # Quadrado para a casa
        for _ in range(4):
            arquiteto.forward(200)
            arquiteto.left(90)
        
        arquiteto.end_fill()
    
    def desenhar_teto():
        """Desenha o teto triangular"""
        arquiteto.color("red")
        arquiteto.fillcolor("darkred")
        arquiteto.begin_fill()
        
        # Triângulo para o teto
        for _ in range(3):
            arquiteto.forward(200)
            arquiteto.left(120)
        
        arquiteto.end_fill()
    
    def desenhar_porta():
        """Desenha a porta"""
        # Posicionar para a porta
        arquiteto.penup()
        arquiteto.goto(50, 0)
        arquiteto.pendown()
        
        arquiteto.color("brown")
        arquiteto.fillcolor("darkbrown")
        arquiteto.begin_fill()
        
        # Retângulo da porta
        arquiteto.left(90)
        arquiteto.forward(80)
        arquiteto.right(90)
        arquiteto.forward(40)
        arquiteto.right(90)
        arquiteto.forward(80)
        arquiteto.right(90)
        arquiteto.forward(40)
        
        arquiteto.end_fill()
        
        # Maçaneta
        arquiteto.penup()
        arquiteto.goto(80, 40)
        arquiteto.pendown()
        arquiteto.color("gold")
        arquiteto.dot(8)
    
    def desenhar_janelas():
        """Desenha as janelas"""
        posicoes_janelas = [(20, 120), (120, 120), (160, 120)]
        
        for x, y in posicoes_janelas:
            arquiteto.penup()
            arquiteto.goto(x, y)
            arquiteto.pendown()
            
            # Janela
            arquiteto.color("blue")
            arquiteto.fillcolor("lightblue")
            arquiteto.begin_fill()
            
            for _ in range(4):
                arquiteto.forward(30)
                arquiteto.left(90)
            
            arquiteto.end_fill()
            
            # Cruz da janela
            arquiteto.color("black")
            arquiteto.penup()
            arquiteto.goto(x + 15, y)
            arquiteto.pendown()
            arquiteto.left(90)
            arquiteto.forward(30)
            
            arquiteto.penup()
            arquiteto.goto(x, y + 15)
            arquiteto.pendown()
            arquiteto.right(90)
            arquiteto.forward(30)
    
    # Sua implementação aqui...
    # Complete com: árvore, sol, jardim, etc.
    
    turtle.done()

# Executar
desenhar_casa()

🎯 Desafios Bônus:

🚗

Carrinho Animado

Desenhar um carro que se move pela tela

🌺

Jardim Procedural

Gerar flores aleatórias em posições diferentes

🎆

Fogos de Artifício

Animação de explosões coloridas

🕰️

Relógio Funcional

Mostrar hora atual com ponteiros

🎮

Jogo Snake

Cobrinha controlada por teclas

🌌

Sistema Solar

Planetas orbitando o sol

🎓 O que Você Vai Aprender:

📐 Geometria e coordenadas na prática

🎨 Teoria das cores e composição visual

🔄 Animação e movimento programático

🧠 Decomposição de problemas complexos

💡 Criatividade aplicada à programação

🖼️ Galeria de Inspiração:

🎨 Artistas Famosos que Usaram Geometria:

Piet Mondrian: Linhas retas e cores primárias
Wassily Kandinsky: Formas geométricas abstratas
M.C. Escher: Padrões matemáticos impossíveis
Sol LeWitt: Arte conceitual com instruções

🌟 Sua arte pode ser a próxima obra-prima digital!

🔮 Próxima Aula:

Na Aula 9, vamos explorar Programação Web! Aprenderemos a criar páginas interativas na internet! 🌐✨

🎯 Objetivos da Aula

Turtle

Formas

Cores

Projeto

📚 Conteúdo da Aula