Módulo — Turtle

Desenhando com a programação

Introdução

O Turtle (“Tartaruga” em inglês) é um módulo do Python para desenhar utilizando a lógica de programação. É uma extensão da linguagem de programação chamada Logo, a qual foi criada em 1967.

A ideia principal do Turtle é que temos uma Tartaruga em um canvas (tela para desenho), onde utilizamos comandos estruturados em uma determinada lógica para criarmos o nosso desenho.

Pikachu sendo desenhado no Turtle.

Canvas e o Sistema de Coordenadas

Antes de colocarmos nossas tartarugas para desenharem, precisamos entender como as nossas Tartarugas serão localizadas no canvas (tela do desenho).

Existe um sistema de coordenadas, posições x e y, em que sua origem (centro) está localizado no centro do Canvas. É através desse sistema que iremos mover as nossas Tartarugas.

Sistema de coordenadas do Turtle desenhado com o próprio Turtle.

Todas as tartarugas que criarmos estarão inicialmente localizadas na origem (ponto onde x=0 e y=0) desse sistema e estarão sempre virados para a direita.

Posição inicial da Tartaruga.

As tartarugas possuem o formato padrão de seta. Veremos as possíveis formas que as nossas tartarugas podem assumir.

Importando o módulo Turtle

Para utilizar um módulo no Python, utilizamos o comando import (importar) seguido do nome do módulo que queremos importar. Após a importação, já podemos utilizar todos os objetos e funções que o módulo disponibiliza.

O módulo Turtle é importado da seguinte maneira:

import turtle

Criando as Tartarugas

Para utilizarmos qualquer função de um módulo, devemos escrever o nome do módulo, seguido de ponto e mais o nome da função que queremos utilizar.

A função que cria nossas tartarugas é a função Turtle(). Essa função retorna um objeto do tipo Turtle, a qual contém diversos métodos para uso. A sintaxe de uso é a seguinte:

import turtle
# Utilizando a função Turtle() do módulo turtle
tartaruga = turtle.Turtle()

Nota: Turtle() não é bem uma função, mas vamos encarar ela e outras como funções por enquanto.

Podemos criar quantas tartarugas quisermos. Basta guardarmos elas em variáveis diferentes.

Métodos das Tartarugas

Listaremos os métodos mais importantes e que provavelmente utilizaremos em nossas atividades. Para ver a lista completa de métodos, veja a documentação oficial do Turtle.

Formato

• shape(<formato>) — indica o formato que a tartaruga deve ter.

import turtle
# Possíveis formatos
# -> arrow (seta)
# -> blank (invisível)
# -> circle (círculo)
# -> classic (clássica)
# -> square (quadrado)
# -> triangle (triângulo)
# -> turtle (tartaruga)
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")

Tartaruga.

• color(<cor>) — indica a cor que a tartaruga pode ter.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.color("medium aquamarine")

Nota: Uma lista contendo o nome de todas as cores possíveis para as tartarugas no site da Trinket. Basta clicar na cor e visualizar o valor para Turtle name.

O nome da cor selecionada é “steel blue”.

Movimento

• forward(<distancia>) ou fd(<distância>)— indica quantos pixels de distância a tartaruga deve andar para frente.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.forward(100)

• back(<distância>) ou bk(<distancia>) — indica quantos pixels de distância a tartaruga deve andar para trás.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.back(100)

• right(<ângulo>) — indica a rotação, em graus de ângulo, à direita que a tartaruga deve fazer.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.right(90)
tartaruga.fd(100)

• left(<ângulo> — indica a rotação, em graus de ângulo, à esquerda que a tartaruga deve fazer.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.left(90)
tartaruga.fd(100)

• setpos(<x>, <y>) ou setposition(<x>, <y>)— movimenta a tartaruga para a posição específica em x e y.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.setpos(100, 100)

• setx(<x>) — movimenta a tartaruga para a posição x (relativa ao eixo x).

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.setx(100)

• sety(<y>) — movimenta a tartaruga para a posição y (relativa ao eixo y).

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.sety(100)

• pos() ou position() — retorna uma tupla contendo a posição (x e y) atual da tartaruga.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.forward(100)
tartaruga.left(90)
tartaruga.back(50)
print(tartaruga.pos())

• home() — movimenta a tartaruga para a origem do sistema de coordenadas (centro do canvas).

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.setx(100)
tartaruga.sety(300)
tartaruga.home()

• circle(<raio>) — realiza o movimento de um círculo de acordo com o raio específicado.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.circle(50)

Controle da caneta

Nota: Existe uma propriedade chamada pen (caneta) que indica se a Tartaruga está desenhando ou não no canvas. Por padrão, a caneta está sempre ativada.

• penup() — desativando a caneta, movimentos com a tartaruga não realizam desenhos.

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Desativando a caneta
tartaruga.penup()
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.right(90)

• pendown() — ativando a caneta, movimentos com a tartaruga realizam desenhos:

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Desativando a caneta
tartaruga.penup()
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.right(90)
# Ativando a caneta
tartaruga.pendown()
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.left(90)

• speed(<velocidade>) — indica a velocidade da caneta, sendo um valor entre 1 e 10:

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Deixando a tartaruga bem lenta
tartaruga.speed(1)
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.right(90)

• pencolor(<cor>) — indica a cor da caneta:

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Alterando a cor da caneta
tartaruga.pencolor("blue")
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.right(90)

• pensize() — indica o tamanho da caneta:

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Alterando o tamanho da caneta
tartaruga.pensize(5)
# Faça 4 vezes
for step in range(0, 4):
    tartaruga.forward(200)
    tartaruga.right(90)

Métodos especiais de desenho

• stamp() — realiza um carimbo da tartaruga no canvas;

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.fillcolor("aquamarine")
# Desenha um círculo e dá 3 voltas.
for step in range(0, 90):
    tartaruga.forward(10)
    tartaruga.left(4)
    # A cada 20 passos
    if step % 10 == 0:
        tartaruga.stamp()

• write(<string>, <move>, <alinhamento>, <font>) — Escreve um texto no canvas conforme string passada e demais argumentos.
  -> string — string a ser escrita. Caso não seja passada uma string, será feita uma conversão automática para o tipo string;
  -> move — True ou False. Indica se a tartaruga deve se mover até o final do texto escrito;
  -> alinhamento — “right”, “left” ou “center”;
  -> font —Uma tupla contendo o nome da fonte, tamanho e tipo (italic, normal ou bold).

import turtle
tartaruga = turtle.Turtle()
# Apontando pra baixo e removendo a caneta
tartaruga.right(90)
tartaruga.penup()
fonte1 = ("Comic Sans", 20, "italic")
tartaruga.write("Curso", False, "center", fonte1)
tartaruga.forward(40)
fonte2 = ("Comic Sans", 20, "normal")
tartaruga.write("de", False, "center", fonte2)
tartaruga.forward(40)
fonte3 = ("Comic Sans", 30, "bold")
tartaruga.write("Programação", False, "center", fonte3)

• clear() — limpa todo o canvas, removendo tudo que foi desenhado;

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
tartaruga.fillcolor("aquamarine")
# Desenha um círculo e dá 3 voltas.
for step in range(0, 90):
    tartaruga.forward(10)
    tartaruga.left(4)
# A cada 20 passos
    if step % 10 == 0:
        tartaruga.stamp()
# Limpando tela
tartaruga.clear()

Preenchimento

São conjunto de métodos que determinam se alguma forma que está sendo desenhada deve ser preenchida com a cor de preenchimento previamente especificada para a tartaruga.

• fillcolor(<cor>) — indica a cor de preenchimento da tartaruga:

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Alterando a cor de preenchimento
tartaruga.fillcolor("blue")

• begin_fill() — indica que a próxima forma desenhada devem ser preenchidas (deve ser utilizado com end_fill());
• end_fill() — indica que a forma já terminando de ser desenhada e pode ser preenchida (deve ser utilizado com end_fill());

import turtle
tartaruga = turtle.Turtle()
tartaruga.shape("turtle")
# Cor para o quadrado
tartaruga.fillcolor("light cyan")
tartaruga.begin_fill()
# Desenhando um quadrado
tartaruga.forward(100)
tartaruga.left(90)
tartaruga.forward(200)
tartaruga.left(90)
tartaruga.forward(200)
tartaruga.left(90)
tartaruga.forward(200)
tartaruga.left(90)
tartaruga.forward(100)
# Terminando de desenhar um quadrado
tartaruga.end_fill()
# cor para o círculo
tartaruga.fillcolor("aquamarine")
tartaruga.begin_fill()
# Desenhando um círculo
tartaruga.circle(50)
# Terminando de desenhar um círculo
tartaruga.end_fill()

Interações do Canvas (Tela)

A tela pode ser obtida através da função Screen().

import Turtle
tela = turtle.Screen()

Métodos

• bgcolor(<color>) — altera a cor de fundo da janela:

import turtle
tela = turtle.Screen()
tela.bgcolor("pink")

• bgpic(<imagem>)— altera o plano de fundo para uma imagem:

import turtle
tela = turtle.Screen()
# Somente imagens do tipo .gif
tela.bgpic("background.gif")

• register_shape (<imagem>)— cadastra uma forma ou imagem para ser posteriormente utilizado pela tartaruga:

import turtle
tartaruga = turtle.Turtle()
# Imagens
pokemons = ["pikachu.gif", "bulbassaur.gif", "charizard.gif", "squirtle.gif"]
# Posicao de cada imagem
posicoes = [(200, 200), (-200, 200), (-200, -200), (200, -200)]
tartaruga.penup()
# Registrando a imagem, mudando a forma e carimbando
for pokemon, posicao in zip(pokemons, posicoes):
    turtle.register_shape(pokemon)
    tartaruga.shape(pokemon)
    tartaruga.setpos(posicao)
    tartaruga.stamp()

• screensize(<largura>, <algura>, <cor_de_fundo>) — altera o tamanho da janela e, opcionalmente, a cor de fundo.