Corso di introduzione al Python

Secondo incontro

Algoritmo di Euclide
Minimo comune multiplo
Introduzione della grafica in Python (modulo graphics.py)
Grafica cartesiana e grafica della tartaruga
Utilizzo della classe Graf del modulo graftarta2.py
Poligoni stelle spirali
Cattura della finestra grafica e memorizzazione dell'immagine
Movimenti casuali della tartaruga

Primi esempi di programmi in Python

Algoritmo di Euclide
MCD(a,b)*mcm(a,b)=a*b
poligoni regolari (ciclo for)
funzione poli
spirali equiangole

def MCD(m, n):
if m % n == 0:
return n
else:
return MCD(n, m%n)

from graftarta2 import Graf
t=Graf("prova", 500, 300)
t.coordinate(-250,-180,250,180)
def quadrato(lato):
    for k in range(4):
        t.avanti(lato)
        t.destra(90)
quadrato(100)
quadrato(50)

gr=Graf('tarta',500,400)
gr.coordinate(-500,-450,500,450)
gr.setBackground('white')
gr.colorePenna('red')
gr.spessorePenna(3)

#provare 144, 135, 108
def poli(lato, angolo):
    gr.avanti(lato)
    gr.destra(angolo)
    somma = angolo
    while somma % 360 != 0:
        gr.avanti(lato)
        gr.destra(angolo)
        somma = somma+angolo

def spirale(lato, angolo, passo=4):
    while lato < 600:
        t.avanti(lato)
        t.destra(angolo)
        lato = lato + passo

""" simulazione del moto di un insetto
        Il predicato di controllo del ciclo while e' costruito con De Morgan
    """
from graftarta2 import Graf
import random

gr=Graf('moto casuale',600,400)
gr.coordinate(-500,-450,500,450)
gr.nascondi_tarta()
#gr.mostra_palla(10)

def pareti():
    gr.pennasu()
    gr.asPos(-200,400)
    gr.pennagiu()
    gr.destra(-90)
    gr.avanti(200)
    gr.destra(-90)
    gr.avanti(800)
    gr.destra(-90)
    gr.avanti(800)
    gr.destra(-90)
    gr.avanti(800)
    gr.destra(-90)
    gr.avanti(200)
    gr.destra(90)
    gr.pennasu()
    gr.asPos(0,0)
    gr.pennagiu()

def controlla(dist):
    depx, depy = gr.coordx, gr.coordy
    gr.nascondi_tarta()
    gr.pennasu()
    gr.avanti(dist)
    urto=False
    if gr.coordy<=-400:
        urto=True
    if gr.coordx<=-400:
        urto=True
    if gr.coordx>=400:
        urto=True
    if -400<gr.coordx<-200 and gr.coordy>=400:
        urto=True
    if 200<gr.coordx<400 and gr.coordy>=400:
        urto=True
    gr.asPos(depx,depy)
    gr.mostra_tarta()
    gr.pennagiu()
    return urto

def casuale(a1,a2,d1,d2):
    angolo=random.randint(a1,a2)
    gr.destra(angolo)
    dist=random.randint(d1,d2)
    urto=controlla(dist)
    if urto:
        gr.destra(180)
    gr.avanti(dist)

pareti()
n=0
#while not(-200<gr.coordx<200 and gr.coordy>402):
while gr.coordx<-200 or gr.coordx>200 or gr.coordy<402:
    casuale(-90,90,0,50)
    n=n+1
print gr.coordx,'   ', gr.coordy
print n

Lavori di gruppo

Utilizzare la funzione che calcola il MCD per calcolare il mcm tenendo presente che MCD(a,b)*mcm(a,b)=a*b
Scrivere una funzione per il calcolo del MCD di tre numeri
Scrivere delle funzioni per disegnare poligoni utilizzando il ciclo di ripetizioni for i in range(...). Fare attenzione agli angoli esterni dei poligoni.
Eseguire delle rotazioni di poligoni facendo variare l'inclinazione iniziale della tartaruga con destra(angolo)
"Catturare" una immagine grafica con ksnapshot. Se si vuole stampare impostare bianco lo sfondo.
eseguire delle spirali equiangole con angoli vicini a quelli dei poligoni regolari ad es. invece di 90, 89; invece di 72, 70
Cambiare il colore della penna e lo spessore
A partire dal programma inset2.py inserire una seconda finestra di fuga per l'insetto