
Módulos Complementares Python
Explore a programação em Python com os módulos complementares micro:bit ou Turtle, com instruções passo a passo.
Descarregue um ficheiro Zip com todas as unidades
*Estas unidades requerem a tecnologia TI-Nspire CX versão 5.2 ou superior.
Unidade 8: micro:bit com Python
Lição 1: O display
Descarregar documentos do professor / alunoNesta lição, vai escrever os seus primeiros programas em python para controlar o display do micro:bit de diferentes formas. Esta lição está dividida em duas partes:
- Parte 1: encontro alienígena
- Parte 2: exibir imagens
Objetivos:
- Controlar a exibição na placa do micro:bit usando .show( ), .scroll( ) e .show(imagem)
- Controlar a velocidade de exibição usando sleep(ms)
Passo 1
- a sua TI-Nspire CX II tem Sistema Operativo 5.3 ou mais recente
- se sente confortável a programar em python e/ou completou as unidades 1 a 5
- -o seu micro:bit está conectado com a tua TI-Nspire CX II
- seguiu as instruções de configuração e transferência de ficheiros no Guia de iniciação do micro:bit :
https://education.ti.com/pt/teachers/microbit

Passo 2
O display do micro:bit mostra o logótipo da TI, um ícone do estado do Texas com um ponto brilhante perto de Dallas, a casa da Texas Instruments, Inc.

Passo 3
O módulo do micro:bit está instalado na tua Biblioteca Python. Num Editor Python, clica [menu] > Mais módulos e repara que BBC micro:bit se encontra listado na parte de baixo do módulos TI.
Nota: No sistema operativo 5.3 e mais recentes, os módulos de Pyton que estão armazenados na sua pasta Pylib do seu dispositivo aparecem neste menu em adição aos ti_ modules. A sua lista pode diferir da aqui mostrada. Os módulos estão listados alfabeticamente de acordo com o nome do ficheiro, logo BBC micro:bit encontra-se entre os “m’s” da lista, não entre os “B’s”.
Passo 4
Parte 1: encontro alienígena: Como seria de esperar, tal como em qualquer outra primeira experiência de programação, irá começar por exibir uma expressão no display do micro:bit.
Comece um novo documento TI-Nspire e selecione Adicionar Python > Novo para iniciar um novo programa, com o nome ‘saudacoes’. No Editor Python use [menu] > Mais módulos > BBC micro:bit para selecionar o comando import no topo dos itens do menu:
from microbit import *
Dica: Se a mensagem ‘micro:bit não conectado’ alguma vez aparecer, desligue e volte a ligar o micro:bit (reset).
Passo 5
display.show(")
Este comando é encontrado em:
[menu] > Mais módulos > BBC micro:bit > Display > Methods
O comando é inserido como display.show(valor), mas (valor) é apenas um marcador de posição que terá de ser substituído por algo. Dentro dos parênteses, substitui valor escrevendo a sua expressão entre aspas:
“saudações, terráqueos”
Quando puser este programa a correr premindo [ctrl] [R] irá ver as letras da sua expressão aparecerem uma de cada vez, no display.
Se cometer um erro…volte à página 1.1 para editar o seu programa, e depois volte a correr o programa. Esqueceu-se de colocar o texto que queria exibir entre aspas?

Passo 6
Um melhor método para exibir a expressão é:
display.scroll(“saudações, terráqueos”)
que também pode ser encontrado em
[menu] > Mais módulos > BBC micro:bit > Display > Methods
Para completar o comando .scroll( ) pode copiar/colar a expressão a partir do comando .show.
Transforme o anterior comando .show() num #comentário (coloque o cursor nessa linha e prime [ctrl] [T]) para desativá-lo e depois coloque novamente o programa a correr.
Sim, também pode simplesmente alterar de .show para .scroll digitando.

Passo 7
display.scroll(“saudações, terráqueos”, delay = 200)
que faz com que haja um atraso de 200 milissegundos (0.2 segundos) na movimentação. Tente também com outros valores de delay.
Passo 8
Parte 2: Seja.Ainda.Minha.Batida.Coraçãoprima [ctrl] [doc] para inserir uma página e selecione Adicionar Python > Novo para adicionar um novo programa Python ao seu documento (o nosso tem o nome ‘batida’).
No Editor Python, vá a [menu] > Mais módulos > BBC micro:bit e selecione o comando import no topo da lista:
from microbit import *

Passo 9
display.show(valor)
Este comando encontra-se em:[menu] > Mais módulos > BBC micro:bit > Display > Methods
Entre os parênteses substitui “valor” selecionando:Image.HEART
A partir de[menu] > Mais módulos > BBC micro:bit > Display > Images > Set 1> Heart

Passo 10

Passo 11
Volte ao editor do programa na página anterior e adicione outro comando de exibição para mostrar o coração pequeno:
display.show(Image.HEART_SMALL)
Pode encontrar esta imagem no mesmo menu de Imagens:
[menu] > Mais módulos > BBC micro:bit > Display > Images > Set

Passo 12

Passo 13
Criar um ciclo: Para fazer com que os dois corações pisquem repetidamente (‘coração a bater’), inclui os dois comandos de exibição num ciclo. Antes dos dois comandos de exibição insira:
while get_key() != ”esc”:
encontrado em [menu] > Mais módulos > BBC micro:bit > Commands
e faça a indentação dos dois comandos de exibição de modo a que estes formem o corpo do ciclo.
Dica importante: A Indentação é crucial em programação Python. É assim que o python interpreta blocos de ciclo e blocos condicionais. Se os dois comandos de exibição não tiverem uma indentação com o mesmo número de espaços irás ver um erro de sintaxe. Usa a tecla [espaço] ou a tecla [tab] para fazer a indentação das duas linhas na mesma quantidade. Neste Editor, os espaços de indentação estão indicados com símbolos em forma de losango e cor cinzento claro (◆◆), para ajudar a uma indentação apropriada.

Passo 14
Dica: Se alguma vez lhe parecer que o seu programa está encravado num ciclo infinito pressione por alguns segundos a tecla [home/on] da sua TI-Nspire para ‘interromper’ o programa. Isto pode acontecer se utilizar while True: a partir do menu de comandos de forma não apropriada. Nestas lições evita-se esse tipo de estrutura.

Passo 15
Pode ver estes e quaisquer outros comandos python a partir de outros menus. Não está limitado a utilizar apenas o menu BBC micro:bit mas pode ter de fornecer os comandos import apropriados.

Passo 16
Para controlar a velocidade com que o coração bate, adicione dois comandos sleep(), um a seguir a cada comando de exibição:
sleep(1000) significa um atraso de 1000 milissegundos (1 segundo).
Também pode ser encontrado em [menu] > Mais módulos > BBC micro:bit > Commands
Dica: Atenção à indentação!

Lição 2: Botões e Gestos
Descarregar documentos do professor / alunoNesta lição irá aprender a usar os botões e gestos do micro:bit para conseguir criar um programa que permita simular o lançamento de um dado, registando os valores numa lista que será transferida para um gráfico.
Esta lição tem duas partes:
- Parte 1: Investigar os botões e gestos
- Parte 2: Usar um botão ou um gesto para gerar um conjunto de dados
Objetivos :
- Ler e processar as teclas A e B no micro:bit
- Observar a diferença entre .was e .is
- Transferir os dados do python para a TI-Nspire
- Avaliar os dados recolhidos do micro:bit
- Utilizar gestos para controlar o display
Passo 1
Há também um acelerómetro/compasso de 3 eixos no verso do micro:bit e métodos para interpretar o seu movimento e orientação.

Passo 2
Parte 1: Investigar os Gestos e Botões
Crie um programa python num novo documento.
Pressione a tecla [home] e selecione Novo, e depois Adicionar Python >Novo…
O nome que demos ao programa foi botoes_gestos.
Do [menu] > Mais módulos > BBC micro:bit selecione o comando import no topo da lista:
from microbit import *

Passo 3
while get_key()! = ’esc’:
a partir de[menu] > Mais módulos > BBC micro:bit > Commands
Quase todos os teus programas micro:bit serão designados desta forma

Passo 4
◆◆if button_a.was_pressed():
◆◆◆◆print("Botão A")
if fica identado por fazer parte do ciclo while e print( ) fica ainda mais identado por fazer parte do bloco if. Nota que a identação apropriada é muito importante em python. Uma identação errada provoca erros de sintaxe ou de execução não esperada do código. Note que os losangos cinzentos (◆◆) indicam o espaço de identação.
if pode ser encontrado em [menu] > Planos integrados > Controlo.
A condição button_a.was_pressed() pode ser encontrada em
[menu] > Mais módulos> BBC micro:bit > Buttons and Logo Touch
print( ) encontra-se em [menu] > Planos integrados > I/O
Escreva “Botão A” dentro da função print( ).
Nota: is_pressed() será discutido posteriormente.
Passo 5
Prima [esc] e volta para o editor Python.

Passo 6
◆◆if button_b.is_pressed():
◆◆◆◆print("Botão B")
Dica: novamente, preste atenção às identações!

Passo 7
Experimente os botões A e B.
Prima cada botão e prima-e-mantenha-premido cada botão.
Poderá ver a mensagem ‘Botão B’ exibida repetidamente enquanto este botão estiver a ser premido, mas não verás a mensagem ‘Botão A’. Existe uma diferença entre .was_pressed() (que precisa que solte o botão para que ocorra o reset) e .is_pressed(), que apenas verifica se o botão se encontra premido no momento exato em que o comando é processado.
Nota: se carregar no botão B muito rapidamente, o programa poderá não exibir a mensagem “Botão B”, visto que o botão não se encontra premido no momento exato em que o comando if é processado.

Passo 8
Esta lição explora estes gestos e demonstra como utilizá-los para programar a tua TI-Nspire CX II com o micro:bit.

Passo 9
- Recolha o valor do gesto do micro:bit e armazene-o na variável g:
◆◆g = accelerometer.current_gesture()
Dica: novamente, preste atenção às indentações!
Escreve ◆◆g = e depois
Encontre accelerometer.current_gesture() em
[menu] > Mais módulos > BBC micro:bit > Sensors > Gestures >
Por fim, exiba o valor de g:
◆◆print(g)
Nota: print( ) encontra-se em [menu] > Built ins > I/O
Note que estas duas linhas de commando estão identadas, um par apenas para ser parte do ciclo while mas não parte do commando if abaixo. Lembre que a identação de cada linha determina o significado, pelo que ATENÇÂO!

Passo 10
Alguns dos gestos disponíveis são: face up, face down, up, down, left, right, shake. Estes são devolvidos como valores string. Consegue ver todos os gestos no seu ecrã?

Passo 11
◆◆if accelerometer.was_gesture(“face down”):
◆◆◆◆print(“face para baixo”)
Os métodos dos gestos e as suas “strings” encontram-se em:
[menu] > Mais módulos > BBC
micro:bit > Sensors > Gestures
Sim, pode simplesmente escrever as strings dos gestos mas no método .was_gesture() deve corresponder exatamente ao item do menu.
Quando correr este programa, irá reparar numa mudança no output:
.current_gesture() exibe constantemente o gesto.
.was_gesture() apenas exibe quando o gesto muda.
Passo 12

Passo 13
Exibe o valor apenas no micro:bit. Tente fazê-lo antes de passar ao passo seguinte. Utilizaremos o programa atual e adicionaremos linhas de código para simular o lançamento do dado.
Consegue determinar o número de pintas na face inferior do dado apresentado na fotografia?

Passo 14
from random import * e randint() podem ser ambos encontrados em
[menu] > Aleatório
O resto do comando ◆◆◆◆dado = randint(1, 6) é escrito manualmente e cuidadosamente indentado porque faz parte do bloco if button_a…
Novamente, cuidado com as indentações.

Passo 15
display.show(dado)
para exibir o valor do dado no display do micro:bit.
Execute o programa novamente. Quando prime o botão A, pode observar a mensagem 'Botão A' no ecrã e o número no visor do micro:bit muda... mas nem sempre! Por vezes o número aleatório selecionado é o mesmo que o último número. Cada premir do botão é um 'evento independente'.

Passo 16
Adicione comandos ao programa para:
- Criar uma lista em branco
- Adicionar (.append) o valor do dado à lista
- Armazenar a lista do python para a TI-Nspire CX II

Passo 17
lançamentos = [ ]
Os parêntesis retos encontram-se no teclado e em [menu] > Planos integrados > Listas
Depois de definido valor do dado, este é adicionado à lista:
lançamentos.append(dado)
.append() pode ser encontrado em [menu] > Planos integrados > Listas
No final do programa, a lista definitiva é guardada numa lista TI-Nspire:
store_list(“lançamentos”, lançamentos)
a função store_list encontra-se em [menu] >BBC micro:bit >Commands
Nota: os dois comentários foram removidos de modo a que todo o código possa caber no ecrã. Podes deixar esses comentários no programa.

Passo 18
Prima [ctrl]-[doc] ou [ctrl]-[I] para inserir uma nova página e selecione a aplicação de Dados & Estatística. Um conjunto de pontos encontra-se disperso no ecrã. Clique na mensagem ‘Clicar para adicionar variável’ no fundo do ecrã e selecione a lista lançamentos. Consegue ver o ecrã à direita? Cada ponto corresponde a um lançamento do dado. Que informação consegue retirar do gráfico? É capaz de transformar o gráfico de pontos num histograma? Dica: observe o [menu].
Podemos modificar o programa de diversas formas; por exemplo: mostrar (print) o número de lançamentos executados, à medida que estes vão sendo simulados.
Nota: O botão B e o gesto não têm efeito sobre o dado. Tente modificar o código de modo a que o dado seja lançado apenas quando “agitar” o micro:bit.
Lembre-se de gravar o documento!

Passo 19
- print(“terminado.”) no final do programa para saber que este terminou.

Passo 20
Executa o programa premindo [ctrl] [R] no Shell. Pressiona o botão A no micro:bit para dar início aos lançamentos do dado e observa o gráfico de pontos!
O gráfico irá exibir a mensagem ‘No numeric data’ inicialmente, porque a lista de lançamentos (lançamentos) foi limpa pelo programa, mas não se preocupes: se premir o botão A inicia a marcação dos dados.

Lição 3: Absorção de luz
Descarregar documentos do professor / alunoNesta lição, deverá monitorizar o sensor de luminosidade do micro:bit e organizar os dados numa lista TI-Nspire para posterior análise.
Objetivos:
- Ler e exibir o sensor de brilho no micro:bit
- Transferir dados do python para a TI-Nspire CX II
- Analisar os dados recolhidos do micro:bit
Passo 1

Passo 2
Pressionar o botão [home] e selecionar Novo > Adicionar Python >Novo…
Demos ao programa o nome de brilho.
Para verificar os valores que o sensor de luz consegue detetar, escreva o programa abaixo usando os menus do BBC micro:bit:
from microbit import *
while get_key() != "esc":
◆◆brilho = display.read_light_level()
◆◆print("brilho = ",brilho)
Encontra var= .read_light_level() no [menu] > BBC micro:bit >Sensors ; bright será o nome da variável que escreverá.
Relembrar: [menu] > Mais módulos > BBC micro:bit > Commands> while get_key() != "esc":
Não se esqueça de identar as duas últimas linhas de código, pois assim fazem parte do corpo do ciclo while.

Passo 3
Corra o programa e aponte o ecrã do micro:bit para a fonte de luz. O que for exibido no ecrã não é relevante. Aproxime e afaste o micro:bit e observe a variação dos valores no ecrã da TI-Nspire CX II. Deverá observar valores entre 0 e 255.
Como seria de esperar, quanto mais longe o micro:bit se encontra da fonte de luz, menor será o nível de luminosidade. Agora vai adicionar código ao programa, de modo que este possa recolher os dados relativos ao nível de luz e a criar um gráfico de dispersão luz vs. tempo.Pressione [esc] para terminar o programa e voltar ao Editor.

Passo 4
tempos = [ ]
brilhos = [ ]
Encontre os parênteses retos no teclado [ctrl] [left parenthesis] ou no menu [menu] > Planos integrados > Listas
Antes do ciclo while, adicione uma linha para iniciar um contador de tempo (t) em 0:
t = 0
Evite usar a palavra ‘tempo’ como variável porque já existe um modulo de tempo. Além disso, é boa prática pluralizar os nomes das listas visto que estas podem conter vários valores.

Passo 5
◆◆t = t + 1

Passo 6
◆◆times.append(t)
◆◆brights.append(brilho)
.append( ) pode ser encontrado em [menu] > Planos integrados > Listas
Estes códigos adicionam o valor atual de luminosidade e o valor t (tempo) às listas.

Passo 7
◆◆sleep(1000)
a seguir aos dois comandos .append. Este commando pausa a recolha de dados durante um segundo entre amostras. sleep( ) pode ser encontrado em:
[menu] > BBC micro:bit > Commands
É importante lembrar que quando usamos o micro:bit, sleep( ) utiliza milisegundos como argumento. Esta amostragem ocorre uma vez por segundo.

Passo 8
Comece no início de uma nova linha (sem identação!).
Encontra store_list() em [menu] > BBC micro:bit > Commands. São necessários dois argumentos: o “nome da lista TI-Nspire” entre aspas e o nome da lista python, sem aspas.
Neste programa, as listas python são armazenadas sob a forma de listas TI-Nspire imediatamente antes do programa terminar, quando pressionas [esc] para sair do ciclo.

Passo 9
Pressione [esc] para terminar o programa.
Repita o processo até sentir que tem um “bom” conjunto de dados.
Dica: A lanterna de um smartphone funciona lindamente!

Passo 10

Passo 11
Clique no espaço ‘Clica para adicionar variável’ no lado esquerdo do ecrã e selecione a lista brilhos. Esta é a variável dependente. O gráfico da dispersão deverá aparecer como na figura.
Poderá ter de correr o programa várias vezes de modo a obter uma “boa” curva como a apresentada na figura. Poderá ser também necessário ajustar a janela para dados diferentes.
Poderá ser ainda necessário ajustar o intervalo de tempo entre amostras, assegurando sempre que editas o argumento da variável sleep(1000 ) e o valor do contador. (t = t + 1).
Em que é que repara?
- Que padrão observa? Que modelo matemático se adequa ao comportamento físico?
- Utilize as ferramentas de análise de dados da TI-Nspire para determinar um bom modelo matemático para o seu conjunto de dados.

Aplicação: Lançar o dado
Descarregar documentos do professor / alunoNesta Apliacação, deverá escrever um programa que permita recolher dados utilizando o micro:bit e executar o programa enquanto observa um gráfico de barras a crescer numa página em separado da TI-Nspire
Objetivos :
- Escrever um programa para recolha de dados no micro:bit
- Criar um gráfico dinâmico em Dados e Estatística
Passo 1

Passo 2
- Corra o programa python num lado do ecrã (python Shell) e
- Exiba um gráfico de pontos (ou histograma) dos dados recolhidos, em simultâneo com o funcionamento do programa python (utilizando a aplicação Dados e Estatística).

Passo 3
somas = [ ]
Armazene, imediatamente, a lista numa variável TI-Nspire (com o mesmo nome).
store_list(“somas”, somas)
de modo a que a lista TI-Nspire se encontre também vazia.
print( ) algumas instruções para o utilizador, antes do ciclo começar. Vamos usar o gesto “agitar” para lançar os dados.

Passo 4
- Lançar dois dados(gerar dois inteiros aleatórios)
- Adicionar os valores
- Adicionar a soma à lista somas
- Exibir os valores dos dois dados, a sua soma e o número do lançamento no ecrã da TI-Nspire. Dica: len(somas) é o número do lançamento.
- Exibir ambos os valores do dado no display do micro:bit
- Armazenar a lista numa variável da TI-Nspire

Passo 5
- Para lançar o dado, use um gesto ou o prima uma tecla:
◆◆if accelerometer.was_gesture("shake"):
◆◆◆◆display.clear()
◆◆◆◆l1 = randint(1,6)
◆◆◆◆l2 = randint(1,6)
Tome atenção às identações.

Passo 6
sum = l1 + l2
sums.append(soma)

Passo 7
display.clear()
display.show(l1)
sleep(250)
display.clear()
display.show(l2)
sleep(250)
Talvez prefira utilizar um intervalo mais longo no comando sleep( ). Se tiver escrito o código de forma correta e na sequência apropriada, tente correr o programa e agitar o micro:bit. Deverá ver dois valores exibidos no micro:bit.

Passo 8
◆◆◆◆print (l1, "+", l2,"=",soma,", ","nexp =", len(somas))
Resultando nas linhas demonstradas na imagem.
Cuidado com a identação!
Passo 9
◆◆◆◆store_list(“somas”, somas)
O comando store_list( ) encontra-se situado profundamente nos blocos while e if, de modo a que a lista TI-Nspire seja atualizada de cada vez que um novo par de dados é lançado.

Passo 10
Na python Shell (a seguir a >>>) pressione [ctrl] [doc] ou [ctrl] [I] para inserir uma página. Selecione a aplicação Dados e Estatistica. Deverá observar um ecrã semelhante àquele apresentado na imagem à direita. Os dados da soma encontram-se dispersos pelo ecrã.

Passo 11

Passo 12

Passo 13
Á medida que vai recolhendo dados (agitar o micro:bit para lançar o dado), os valores das somas aparecem como pontos na aplicação Dados e Estatistica, à direita.
Pressionando [esc] terminará o programa e pode fazer muitas coisas com a análide de dados do TI-Nspire.
Agora, pressionando [ctrl] [R] novamente (no python Shell) irá correr novamente o programa.
Dica: para limpar o Shell no início de cada recolha de dados adiciona o comando::
clear_history()
encontrado no [menu] > Mais módulos > BBC micro:bit > Commands
no início do programa.
Divirta-se e não se esqueça de gravar o documento!

- Lição 1
- Lição 2
- Lição 3
- Aplicação
Unidade 9: Módulo Turtle em TI-Python
Lição 1: Iniciação com polígonos
Descarregar documentos do professor / alunoNesta lição, vai instalar o módulo Turtle na calculadora e escrever os primeiros programas para desenhar alguns polígonos, utilizando instruções que permitam à tartaruga fazer movimentos.
Objetivos:
- Instalar o módulo Python
- Desenhar e pintar polígonos
Passo 1
Antes de começar, certifique-se de que a sua TI-Nspire CX II-T tem o Sistema Operativo atualizado.
De seguida, caso não tenha o módulo Turtle instalado, deve aceder à página web https://education.ti.com/pt/product-resources/turtle-module/nspire-python para obter uma pasta compactada, onde encontra o módulo e ainda um guia de iniciação.

Passo 2

Introdução 2
Com o módulo Turtle instalado pode agora incluir os respetivos comandos em linhas de código num programa em Python.
Para que os comandos tenham efeito, deve começar por importar a biblioteca de Turtle para a primeira linha do programa.
Prima [Menu] > Mais módulos > Turtle Graphics > from turtle import*
Surge a instrução from turtle import*, mas também, separado por ponto e vírgula (;), a instrução t=Turtle() na linha de código, a qual cria o objeto Turtle com o nome t.
NOTA: A utilização do ponto e vírgula (;) é a forma como o Python permite que se escrevam duas instruções na mesma linha.
Passo 3

Introdução 3
Voltando ao [Menu], a Mais módulos e depois novamente a Turtle Graphics, encontra oito submenus (2 … 8): Move, Draw, Pen control, Settings, Tell Turtle’s state, Colors, Filling e Commands.
Cada submenu contém funções específicas da tartaruga (e outras), as quais começam com a variável do objeto t, que é o nome padrão da tartaruga (turtle). O nome pode ser alterado e pode também ter-se várias tartarugas no mesmo programa, devendo o utilizador fazer as escolhas que entender.
As funcionalidades do submenu Move podem observar-se na figura. Poderá observar as restantes funcionalidades submenu a submenu.
Passo 4
Para fazer com que a tartaruga desenhe um quadrado, escreva um ciclo de repetição com apenas duas instruções:
for i in range(4):
t.forward(50)# pixels
t.left(90)# graus

Passo 5
Um quadrado – a execução do programa
Depois de introduzir o código, execute o programa (CTRL + R) para perceber se a tartaruga realmente faz um quadrado.
A tartaruga começa na origem, virada para a direita. O valor 50, em forward, refere-se ao número de pixels no ecrã. As linhas de grelha estão separadas por 25 pixels, como se pode observar na legenda no canto inferior esquerdo do ecrã. O valor 90, em left (rotação no sentido positivo), representa 90º.
No final, a tartaruga regressa à origem e fica voltada para a direita. O desenho (gráfico) permanece no ecrã até ser premida uma tecla.

Passo 6
Um polígono regular com n lados – o desenho
Modifique o programa que permitiu desenhar o quadrado para permitir que o utilizador introduza o número de lados para que a tartaruga desenhe um polígono regular com esse número de lados. Utilize, antes do ciclo de repetição, a instrução:
n=int(input(“Quantos lados? “))
e altere o código do ciclo de repetição.
NOTA: Um pouco mais de conhecimento matemático será necessário para decidir qual o ângulo de rotação, que passará a ser a divisão de 360º por n. Para desenhar o heptágono da figura o ângulo é 360º/7.
Passo 7
Um polígono regular com n lados – o código
Um programa para desenhar o heptágono observado anteriormente ou outro polígono regular à escolha, em função do número de lados, pode ser o que se observa na figura ao lado.
Coloque a instrução t=Turtle() após a linha de código para introdução do número de lados para que a pergunta seja feita antes de surgir o ecrã do desenho.
Para alterar a velocidade da tartaruga, utilize t.speed(0), instrução que pode encontrar no submenu Settings (Menu > Mais módulos > Turtle Graphics > Settings). O argumento entre parênteses é um valor entre 0 a 10, sendo 0 o que corresponde ao movimento mais rápido.
NOTA: Faça algumas experiências com outros valores de n, de velocidade e de medida do lado do polígono.
Passo 8
Colorir o polígono – introdução
Há dois métodos para atribuir cor a uma figura:
t.pencolor(r,g,b) - no subemu Pen control
t.fillcolor(r,g,b) - no submenu Filling
O terno (r,g,b) corresponde ao código RGB da cor pretendida.
t.pencolor permite colorir linhas, nesta caso os lados do polígono. Se a instrução estiver no ciclo de repetição e o código RGB for automaticamente alterado, pode ter um lado de cada cor.
t.fillcolor permite preencher a figura com a cor do código RGB considerado.

Passo 9
Um pentágono vermelho
Para obter um pentágono com o interior vermelho, antes de o desenhar tem de escolher a cor, com a instrução t.fillcolor(255,0,0) do submenu Filling. Depois, tem de dar ordem para início do preenchimento com a instrução t.begin_fill(), do mesmo submenu.
Durante o ciclo de repetição, o sistema guarda a lista de vértices “visitados”.
No final, para que se observe o polígono com o interior preenchido tem de colocar a instrução t.end_fill().


Passo 10
Arte com polígonos I
Modifique o programa para fazer polígonos de forma aleatória, seja em relação ao número de lados, à cor ou ao local de início do desenho.
- Utilize t.hideturtle() e t.hidegrid() para melhorar a aparência e a velocidade.
- Utilize wille get_key()!=”esc” no ciclo de repetição principal para parar ao premir a tecla “esc”.
- Utilize t.penup(), t.goto(,), t.setheading() e t.pendown() para colocar a tartaruga num ponto de partida do ecrã aleatório, virada numa direção aleatória, para um comprimento aleatório do lado do polígono.
NOTA: O ecrã da tartaruga tem um número de pixels que varia de -159 a 159 na horizontal e de -106 a 106 na vertical e não há problema se sair fora do ecrã. Pode usar qualquer ângulo, em graus, para rotação.
Lição 2: Cor e movimento
Descarregar documentos do professor / alunoNesta lição, vai continuar a descobrir o módulo Turtle, utilizando as opções desenho e as opções de movimento.
Objectifs :
- Desenhar um triângulo isósceles e colorir o interior
- Colorir um círculo
- Integrar estes dois objetos para fazer um desenho
Intro 2
Como desenhar a figura ao lado utilizando um programa em Python e o módulo Turtle?
Parece bastante simples. Mas será realmente simples?
Observe que a figura é constituída por:
- um círculo amarelo centrado no ecrã
- um conjunto de triângulos isósceles iguais colocados à volta do círculo.
Para desenhar o sol importa perceber a construção de cada elemento em separado: o círculo e o triângulo.
Passo 1
Desenhar um triângulo isósceles 1
Vejamos as etapas a seguir para construirmos um triângulo isósceles:
- Inicie um novo programa num editor de Python e nomeie-o “Triangulo”.
- Importe a biblioteca de Turtle e ainda a biblioteca de funções matemáticas (math) para os cálculos trigonométricos.
- Crie a variável c, correspondente à medida da base do triângulo com 60 pixéis (c=60).
- Crie a variável b, exprimindo em radianos um ângulo de 70º.
- Crie a variável h, medida de cada um dos lados iguais.

Passo 2
Desenhar um triângulo isósceles 2
Mais algumas configurações para o nosso triângulo:
- Poderá fixar a velocidade da tartaruga com t.speed(), escolhendo como argumento um número natural ente 0 e10.
- No menu 8: Filling pode escolher a cor no sistema RGB para colorir o interior do polígono.
Nota: Há, neste sistema, tantas cores quantos os códigos que se podem formar com um terno em que o primeiro elemento é a intensidade de vermelho, de 0 a 255, e cada um dos seguintes, também no mesmo intervalo, respetivamente verde e azul. - Os comandos t.begin_fill() e t.end_fill() são utilizados para estabelecer os momentos inicial e final do preenchimento do polígono.
Passo 3
Desenhar um triângulo isósceles 3
Continuando a completar o código para o nosso triângulo:
- No menu 2: Move, use os comandos t.forward() e t.left() para completar a construção do triângulo.
- Por uma questão estética esconda a tartaruga com o comando t.hideturtle() localizado no menu 5: Settings.
- Não se esqueça do comando t.done() no final para exibir o desenho no final da execução do programa.
Nota: O triângulo a desenhado podia ter sido simplificado. Foi construído desta forma para serem melhor compreendidos os cálculos, salientando os dois triângulos retângulos e a escolha do ponto de partida.
- Execute o programa e observe o triângulo obtido.
- Faça várias experiências, modificando a cor de fundo e do contorno, as medidas, …
Passo 4
Mudar o sítio do triângulo
- No menu 2: Move, escolha o comando t.goto(x,y). Este comando permite indicar o ponto, através da suas coordenadas (x,y), para onde a tartaruga se deve mover.
- O local da linha de código com este comando é muito importante. Neste exemplo será antes do desenho do triângulo. Coloque t.goto(50,25).
- Execute o programa. Foi realmente feita uma translação para o ponto (50,25), com a desvantagem de ter ficado o rasto dessa mudança, um segmento de reta do ponto (0,0) ao ponto (50,20).
Passo 5
As cores no Turtle
Nota: As cores podem ser escolhidas, também, no menu 7: Colors, para além do uso do código RGB.
Passo 6
Eliminar o rasto do deslocamento
Vejamos como eliminar o segmento que traduz a deslocação do triângulo:
- Para eliminar o segmento de reta definido pelos pontos de coordenadas (0,0) e (50,25), vá ao menu 4: Pen control e utilize os comandos 2: t.penup() e 3: t.pendown().
Nota: Naturalmente, o comando para deslocar a tartaruga deverá ser incluindo entre estes.
- Execute o programa e observe o efeito produzido por estas três linhas de código.
Passo 7a
Mudar a orientação do triângulo
- No menu 1: Move, selecione o comando t.setheading(), esta instrução permitirá rodar a seta (cabeça) do triângulo que representa a tartaruga.
- Coloque esta instrução antes dos comandos para desenhar o triângulo
Nota: t.setheading(graus) define a medida do ângulo de rotação da tartaruga, em graus. Se os valores da medida forem positivos, a rotação faz-se no sentido anti-horário e a rotação será no sentido horário para valores negativos.

Passo 7b
- Em comparação com a orientação anterior, o triângulo deve rodar 90º no sentido horário, portanto terá que se inserir a instrução t.setheading(–90).
- Execute de novo o programa e observe o resultado obtido
- Para desenhar o sol raiado, será assim possível criar a coroa de raios.
Passo 8a
Os comandos do tipo t.fillcolor(r,g,b), associados a t.begin_fill() e t.end_fill() apenas funcionam para polígonos e não para círculos.
A instrução t.circle() apenas desenha uma circunferência e não o seu interior.

Passo 8b
Deverá então ser utilizado o comando t.dot(diâmetro) que se encontra no menu 3: Draw. A ideia subjacente é o desenho de um “ponto” com um determinado diâmetro, definido em pixéis.
O comando t.pencolor(r,g,b) permite a escolha da cor do lápis para desenhar esse ponto.
- Crie um novo programa e designe-o por círculo.
- Escreva os comandos que observa na figura para desenhar um círculo amarelo.
- Teste o programa, executando-o.
Passo 9a
Código para o programa do Sol raiado
Vamos terminar este projeto usando os programas anteriores para construir o nosso sol raiado.
- Modifique o programa triangulo e crie agora um programa para desenhar o Sol com os raios à volta.
- A representação geométrica ao lado fornece os nomes das variáveis para utilizar no programa.
- Ao redor do círculo central do Sol temos, a cada 30º, um triângulo isósceles de base c e lado h (medida de cada um dos lados iguais). Estes triângulos são representados numa circunferência de raio r+e.

Passo 9b

- Para orientar corretamente cada triângulo que representa cada raio de sol, utilize o comando t.setheading(–90+30*i), em que i é número de incrementos de 30º.
- O programa completo obtém-se com todos os passos que foram observados até aqui nesta lição, e que se encontram na imagem ao lado. Abaixo coloca-se o código relativo à construção dos raios:
h=c/(2*cos(70*pi/180))
for g in range(0,360,30):
t.goto((r+e)*cos(g*pi/180),(r+e)*sin(g*pi/180))
t.setheading(-90+p*i)
t.pendown()
t.pencolor(251,163,26)
t.begin_fill()
t.fillcolor(251,163,26)
t.forward(c/2)
t.pendown()
t.forward(c/2)
t.left(110)
t.forward(h)
t.left(140)
t.forward(h)
t.left(110)
t.forward(c/2)
i+=1
t.end_fill()
Lição 3: Resolução de um problema
Descarregar documentos do professor / alunoNesta terceira lição irá escrever um programa que lhe permita usar o módulo Turtle do TI-Python para ilustrar a resolução de um problema simples de matemática.
Objetivos:
- Resolver um qualquer triângulo
- Desenhar uma representação geométrica
Intro 2
Introdução
O que propomos é resolver um triângulo escaleno utilizando as relações do matemático Al Kashi.
Este resultado é assim designado em homenagem a al-Kâshî, matemático persa do início do século XV.
Estas igualdades são, também, conhecidas por "Lei dos Cossenos", e generalizam o Teorema da Pitágoras para triângulos não retângulos.
O teorema de Al-Kâshî afirma:
sendo [ABC] um qualquer triângulo e ∝ a medida em radianos doângulo BAC, então

Para simplificar, tendo em atenção a notação constante na figura ao lado, podemos afirmar que, para cada um dos lados do triângulo, temos as seguintes igualdades:
Passo 1
O problema
Suponha que são conhecidas as medidas dos três lados de um dado triângulo.
Escreva um programa, com recurso ao módulo Turtle do TI-Python, que:
- apresente a representação do triângulo;
- obtenha e apresente as medidas dos ângulos internos, em graus.
A medida do comprimento dos lados será dada em pixéis.

Passo 2
Criar um novo programa em TI-Python
Na aplicação TI-Python:
- crie um novo programa e designe-o por TL3;
- importe, para já, apenas o módulo Matemática;
- crie as variáveis a, b e c correspondentes aos comprimentos, em pixéis, dos lados do triângulo.
Os comprimentos dos lados serão entradas inteiras do nosso programa, conforme podemos observar no ecrã ao lado.

Passo 3
Inserir as instruções para calcular as amplitudes dos ângulos internos
De seguida, usando a “Lei dos cossenos”, escreva as linhas de código para:
- calcular o valor dos cossenos dos ângulos
respetivamente cos_a, cos_b, cos_c.
- calcular, usando a função trigonométrica inversa acos(), os valores das amplitudes dos ângulos internos do triângulo, em graus e arredondados às décimas.

Passo 4
Inserir as instruções para desenhar o triângulo
Nesta etapa irão ser inseridas as linhas de código, do módulo Turtle, que permitam representar geometricamente o triângulo. Para isso, considere que:
- deve, agora, importar o módulo Turtle;
- o desenho do triângulo começará no ponto de coordenadas (-100,-80), em pixéis, isto é, a posição de um dos seus vértices;
- serão usadas as instruções var=t.xcor() e var=t.ycor() para mais facilmente serem inseridas as etiquetas nos vértices do triângulo.
Estas instruções são usadas para se guardar as coordenadas da tartaruga, num dado momento, e podem ser obtidas pressionando tecla [Menu], depois A: Mais módulos, em seguida, Turtle Graphics e, finalmente, 6: Tell Turtle's state; e 3: var=t.xcor. - a instrução t.pencolor (0,0,255) é usada para colocar a caneta em azul, usando-se o código RGB. Também pode usar-se a instrução t.pencolor("azul").
Passo 5
Inserir as instruções para colocar as etiquetas com os nomes dos vértices
A última parte desta lição consiste em inserir as instruções que permitem exibir os nomes dos vértices do triângulo, bem como os valores das amplitudes dos seus ângulos internos. Para isso:
- levantar a caneta inserindo a instrução t.penup();
- ativar a cor vermelho da caneta para a escrita, inserindo-se a instrução t.pencolor(“red”);
- colocar o cursor, a tartaruga, junto de cada vértice usando a instrução t.goto(x,y) e as variáveis onde se guardaram as coordenadas;
- tilizar a instrução t.write(“text“) para escrever a designação do vértice;
- utilizar a instrução t.write(Var) para escrever a amplitude do ângulo interno correspondente a cada vértice.
Passo 6
Executar o programa para resolver vários triângulos
Por fim, execute o programa agora criado para resolver triângulos para quaisquer valores de a, b e c, que verifiquem a desigualdade triangular.
Por exemplo para:
- a=100, b=150 e c=200
- a=160, b=250 e c=200
Aplicação: Construção de uma figura complexa
Descarregar documentos do professor / alunoNesta lição de aplicação irá mobilizar os conhecimentos trabalhados nas anteriores lições por forma a construir um programa que lhe permita a conceção de um projeto.
Objetivos:
- Aplicar os conceitos trabalhos nas lições anteriores.
- Construir uma figura complexa com recurso à programação.
Intro 2
Introdução
Nas atividades das três lições anteriores vimos como usar o módulo Turtle, num programa TI-Python, na construção de uma figura geométrica, sendo que foi necessário antecipadamente realizarem-se cálculos matemáticos.
Para melhor perceção do programa usamos, habitualmente, comentários inseridos entre o código, sempre que oportuno, e também procuramos que cada tarefa complexa fosse dividida num certo número de tarefas simples.
Nesta lição iremos construir, geometricamente, uma árvore de Natal, sendo que o nosso programa principal se dividirá nas seguintes funções mais simples:
- desenhar e colorir um triângulo isósceles;
- desenhar o pé da árvore;
- desenhar e colorir uma estrela;
- enfeitar e reluzir a árvore
Passo 1
Criação do projeto
Todos os projetos têm as suas especificidades. Neste, em que utilizaremos o módulo Turtle e mostrará um objeto gráfico, teremos os constrangimentos resultantes do tamanho do ecrã (grelha unitária de 25 pixéis).
As especificidades do projeto são:
a decoração da árvore, que consiste na colocação de pontos coloridos, usando a instrução t.dot(diâmetro), sendo o tamanho e posição aleatórios;
- ·os pontos coloridos, que devem estar contidos num triângulo isósceles (a árvore);
- a representação anterior será obtida utilizando um software de geometria dinâmica no qual o sistema de coordenadas ortonormais é idêntico à grelha do módulo Turtle, o que facilitará trabalho;
- os pontos de coordenadas (–75, –75); (75, –75) e (0, 75) serão os vértices do triângulo;
- as retas de equação reduzida y = 2x + 75, y = −2x + 75 e y = −75 delimitarão o domínio plano de representação dos pontos coloridos (os enfeites).
Passo 2
Criação do programa
Na aplicação TI-Python:
- abra um novo programa e designe-o por Apps_Arvore;
- prima na tecla [Menu] e importe os módulos de Matemática, Aleatório e Turtle Graphics, necessários para este projeto;
- o módulo Aleatório permitirá obter aleatoriamente as posições e o número de objetos coloridos (enfeites).
Passo 3
Desenho do pé da árvore
Comecemos, então, por construir a função que desenhe o pé da árvore. Assim, coloquemos as instruções em Python para:
- ocultar a tartaruga – t.hideturtle();
- colocar o cursor, sem escrever – t.penup(), na posição inicial (0,– 100) – t.goto(0, –100);
- baixar a caneta para se poder desenhar – t.pendown();
- definir a cor do lápis como castanho, correspondente ao código RGB (165, 42, 42) usando a instrução t.pencolor(165, 42, 42);
- de seguida orientar a tartaruga para cima – t.setheading(90);
- para traçar o pé da forma mais simples e ficar bem visível, escolher a espessura mais grossa do lápis – t.pensize(3);
- desenhar o pé com comprimento de 25 pixéis – t.forward(25).
Todas as instruções anteriores estão disponíveis no módulo Turtle, premindo tecla [Menu], depois a opção A: Mais Módulos, seguido de 7: Turtle Graphics e, por fim, escolhendo a opção pretendida.
Passo 4
Desenhar a estrela do cimo da árvore
Para desenhar a estrela vai ser criada uma função que designaremos por estrela(). Poderemos aqui, se necessário, revisitar o guião da Lição 1, na qual foram desenhamos polígonos regulares.
Nesse caso, necessitaríamos de usar um programa num programa, procedendo-se à sua importação usando-se a instrução from PROGRAMA import* disponível no catálogo.
Neste caso, usaremos um novo programa, realizando as etapas:- fixar a estrela no topo da árvore no ponto das coordenadas (0, 75) – t.goto(0,75);
- com a instrução t.fillcolor() completar a coloração dos ramos da estrela;
- preencher os ramos com uma tonalidade laranja de código RGB (255,127,0) – t.fillcolor(255,127,0);
- em cada iteração, mover a tartaruga 30 pixéis para a frente e rodar para a direita por 144 graus.
- cada um dos ângulos interiores da estrela será de 36 graus;
- com 5 iterações ficará perfeitamente construída a estrela, usando o ciclo de controlo while.
Passo 5a
Desenhar uma dada estrela em função do seu tamanho
Vejamos como construir uma função que permita construir uma estrela sólida de uma dada cor. Dependendo do tempo que pretender disponibilizar ao seu projeto, pode optar por este triplo de estrela no cimo da árvore de Natal ou até como um dos elementos de enfeite. Vejamos as principais etapas do código dessa função que se encontra na imagem ao lado:
- a função terá um argumento, o tamanho da estrela - size, designando-se a função por star(), portanto chamando a função com star(size);

Passo 5b
- a estrela será preenchida por uma cor, neste caso cor de laranja cujo código RGB é (225,127,0), usando-se as instruções t.pencolor(225,127,0), para escrever a laranja, e t.fillcolor(255,127,0), para colorir a laranja;
- de seguida usa-se, nos Planos Integrados, o ciclo de controlo For index in range(size), em serão traços dois segmentos consecutivos da estrela;
- repetição 5 vezes das instruções deste ciclo permitirá encerrar o polígono estrela e o preencher na cor pretendida;
- para usar esta função, por fim, fazemos a correr para um tamanho de 30 pixéis – star(30);
- por fim, escondemos a tartaruga – t.hideturtle().
Passo 6
Desenhar a árvore
A tarefas para esta função consiste em construir um triângulo isósceles simples, como já referimos na implementação do projeto.
Todas as medidas (amplitudes dos ângulos, comprimento dos lados, ...) resultam de trabalho preparatório com ambiente de geometria dinâmica.
O triângulo isósceles, a nossa árvore, será preenchido pela cor verdade árvore cujo código RGB é (,121,111) – t.fillcolor(1,121,111).
Passo 7
Desenhar as bolas (enfeites) de Natal
Vamos agora criar a função que nos permitirá desenhar as bolas de enfeites da árvore de Natal, sendo de tamanhos e cores aleatórias. Recordar que para usar as funções aleatórias foi necessário importar, no início do programa, o módulo Aleatório. A função, designada por bolas(), dependerá de um argumento k que define o número de bolas a representar, portanto usaremos bolas(k). Temos ainda que:
- para definir as cores usamos a função randint() que permite gerar inteiros aleatórios, neste caso entre 0 e 255, que definirá a porção de vermelho, R, verde, G, e de azul, B, em cada bola;
o tamanho da bola, mais propriamente o seu diâmetro, é obtida de forma aleatória com a função aleatória randint(5,10);
- também a posição da bola, através das suas coordenadas em pixéis, são obtidas através da mesma função aleatória randint(), desta feita para valores entre –75 e 75 para a abcissa e –90 e 90 para a ordenada;
- por fim, através de um ciclo de controlo, neste caso If …, é garantida a representação da bola caso as suas coordenadas satisfação as condições que definem o domínio plano que define a árvore.
Passo 8
O programa principal
Estão terminadas todas as funções mais simples em que não dividimos o nosso projeto de construção de uma Árvore de Natal, bastará agora colocar no programa a execução destas funções.
Assim, embora sendo indiferente a ordem com que colocarmos as funções se não usarmos pausas, aqui vamos usar uma ordem especifica e com ligeiras pausas de 1 segundo.
A instrução colocada no final do nosso programa t.done() deixa a imagem exibida. Pressionando-se qualquer tecla desaparecerá a imagem e surgir a linha de entrada do Shell Python com >>>.
No editor do programa no Python pode gravar e verificar o programa usando o atalho CTRL + B, e poderá executá-lo através do atalho CTRL + R. No Shell Python podem também executá-lo com o atalho CTRL + R.
- Lição 1
- Lição 2
- Lição 3
- Application
