MOOC Programmeerimise alused - Kursused

6.4 Graafika ja funktsioon

KILPKONN ÕPIB FUNKTSIOONE

Varasemates osades oleme tähtsamate programmeerimise konstruktsioonidega (nt valikulause ja tsükliga) tutvumisel abiks võtnud kilpkonna. Nii saame parema visuaalse ettekujutuse. Ka funktsioonide mõistmisel võib kilpkonnast abi olla. Kilpkonnagraafikas on meil läbivaks teemaks olnud ruudu joonistamine, jätkame sellega siingi.

Mäletavasti kasutasime viimati ruudu joonistamisel tsüklit.

from turtle import *

i = 0
while i < 4:               # Kilpkonn joonistab tsükli abil ruudu. Tsükli keha läbitakse neli korda.
    forward(100)
    left(90)
    i = i + 1              # Muutujat i suurendatakse ühe võrra

exitonclick()

Ruudu joonistamiseks võib defineerida ka spetsiaalse funktsiooni, näiteks nimega ruut. Järgmises näiteprogrammis on see funktsioon ilma argumentideta.

Näiteprogramm. Ruut III

from turtle import *

def ruut():                # Defineerime funktsiooni nimega ruut
    i = 0
    while (i < 4):
        forward(100)
        left(90)
        i = i + 1

ruut()                     # Kutsume funktsiooni ruut välja. Kilpkonn joonistab ruudu küljega 100 pikslit
right(45)                  # Pöörame paremale 45°
ruut()                     # Kutsume uuesti funktsiooni ruut välja

exitonclick()

Eelmise näiteprogrammi puhul joonistab kilpkonn alati ruudu, mille külje pikkus on 100 pikslit. Selleks, et me saaksime muuta ruudu külje pikkust vastavalt soovile, lisame funktsiooni ruut argumendi. Nüüd saab seda funktsiooni rakendades joonistada erineva suurusega ruute. Näiteks ruut(50) korral on argumendi väärtuseks 50 ja ruudu külje pikkuseks tulebki 50. Kui argumendiks on 75 (ruut(75)), siis tuleb külje pikkuseks 75.

Järgnevas programmis ongi seda demonstreeritud.

Näiteprogramm. Ruut IV

from turtle import *

def ruut(külg):            # Defineerime funktsiooni nimega ruut, mille argumendiks on ruudu külje pikkus
    i = 0
    while (i < 4):
        forward(külg)      # Siin kasutataksegi argumenti
        left(90)
        i = i + 1

ruut(50)                   # Kilpkonn joonistab ruudu küljega 50 pikslit
ruut(75)                   # Kilpkonn joonistab ruudu küljega 75 pikslit

exitonclick()

Eelmine kord, kui kilpkonna käsitlesime, olid vaatluse all ka värvimise võimalused. Neid on tegelikult veelgi. Näiteks muudetakse taustavärvi käsuga bgcolor("värvi_nimetus"). Teeme programmi, mis muudab ringjoone roheliseks ja lisab punase raamiga ruudu. Tausta värvime helesiniseks. Selleks, et ruutu ei joonistataks ringi peale, kasutame käske:

up() - tõsta pliiats üles;
down() - langeta pliiats vastu "paberit".

Lisaks oskab kilpkonn muuta pliiatsi värvi ja täitevärvi vastavalt käskudega:

pencolor("värvi_nimetus") - muuda pliiatsi värvi (tõlkes pliiatsi värv);
fillcolor("värvi_nimetus") - muuda täitevärvi (tõlkes täitevärv).

Näiteprogramm. Ring ja ruut

from turtle import *

def ruut(n):               # Defineerime funktsiooni ruudu joonistamiseks
    i = 0
    while (i < 4):
        fd(n)
        lt(90)
        i = i + 1

pencolor("#32CD32")        # Kilpkonn muudab pliiatsi värvi laimiroheliseks
fillcolor("red")           # Kilpkonn muudab täitevärvi punaseks
begin_fill()               # Kilpkonn alustab ringi värvimist
circle(100)                # Kilpkonn joonistab ringi raadiusega 100 pikslit
end_fill()                 # Kilpkonn lõpetab ringi värvimise

up()                       # Pliiats üles
fd(300)                    # Kilpkonn liigub edasi 300 pikslit
lt(90)                     # Kilpkonn pöörab 90° vasakule
fd(50)
down()                     # Pliiats alla

pencolor("red")            # Kilpkonn muudab pliiatsi värvi 
fillcolor("#32CD32")       # Kilpkonn muudab pliiatsi värvi punaseks, täitevärvi laimiroheliseks
begin_fill()
ruut(100)                  # Kilpkonn joonistab ruudu küljega 100 pikslit
end_fill()

bgcolor("pale turquoise")  # Muudame taustavärvi helesiniseks

exitonclick()

Eelnevalt oleme vaadanud programme, mis joonistavad kilpkonnaga ruute või ringe. Kui me tahame, et kilpkonn oskaks luua ka teisi kujundeid, näiteks korrapäraseid hulknurki, siis defineerime selleks vastava funktsiooni.

Kirjutame alamprogrammi hulknurk(n), mis joonistaks soovitud nurkade arvuga hulknurga. Selles funktsioonis on argumendiks n hulknurga nurkade arv. Näiteks viisnurga joonistamiseks anname argumendi n väärtuseks 5 (hulknurk(5)). Selleks, et leida mitme kraadi võrra kilpkonn pöörama peab, kasutame korrapärase hulknurga sisenurga suuruse leidmiseks valemit (n - 2) * 180 / n, kus n on nurkade arv. Seejärel lahutame saadud väärtuse sirgnurgast (180°). Kui valemit lihtsustada, siis saame 360 / n.

from turtle import *
def hulknurk(n):     
    i = 0
    nurk = 360 / n         # Arvutatakse kilpkonna pööramise nurga suurus
    while (i < n):
        forward(100)
        left(nurk)
        i = i + 1

hulknurk(5)
exitonclick()

Saame kirjutada hulknurkade joonistamiseks järgmise programmi, kus hulknurga funktsiooni argumentideks on nurkade arv ja külje pikkus: hulknurk(n, külg). Näiteks kuusnurga joonistamiseks, mille külg on 150 pikslit, kirjutame hulknurk(6, 150).

Näiteprogramm. Hulknurk

from turtle import *

# Defineerime funktsiooni nimega hulknurk. Argumendid on nurkade arv ja külje pikkus
def hulknurk(n, külg):     
    i = 0
    nurk = 360 / n         # Arvutatakse kilpkonna pööramise nurga suurus
    while (i < n):
        forward(külg)
        left(nurk)
        i = i + 1

fillcolor("green")
begin_fill()
hulknurk(6, 150)           # Kilpkonn joonistab rohelise korrapärase kuusnurga küljega 150 pikslit
end_fill()

fillcolor("red")
begin_fill()
hulknurk(7, 50)            # Kilpkonn joonistab punase korrapärase seitsenurga küljega 50 pikslit
end_fill()

exitonclick()

Kilpkonnaga saab veel igasuguseid trikke teha ning võimalusi on veelgi. Lähemalt saab uurida Pythoni turtle mooduli dokumentatsioonist. Näiteks kuidas muuta pliiatsi paksust või kilpkonna kuju. Näiteks shape("turtle") muudab kilpkonna kuju. Kilpkonna programmeerimisel laske fantaasial lennata, kasutades kõiki oma teadmisi tsüklite, tingimuslausete, muutujate jne kohta.

Järgnevalt esitame näite, mis joonistab naerunäo. Kui me ei soovi joonistada tervet ringjoont, vaid osa sellest, siis saame kasutada käsu circle kahe argumendiga väljakutset circle(r, d). Selles käsus tähistab r ringi raadiust ja d kesknurka kraadides. Näiteks kui soovime joonistada veerand ringjoonest raadiusega 100 pikslit, siis saame kasutada käsku circle(100, 90).

Näiteprogramm. Naerunägu

from turtle import *

def silm():                # Defineerime funktsiooni silmade joonistamiseks      
    pencolor("#000000")
    fillcolor("#FFFFFF")
    begin_fill()
    circle(25)
    end_fill()

pencolor("#000000")        # Pea
fillcolor("#FFFF00")   
begin_fill()
circle(100)                  
end_fill()

up()                               
bk(45)
lt(90)
fd(100) 
rt(90)
down()

silm()                     # Vasak silm 

up()                              
fd(90) 
down()

silm()                     # Parem silm

up()                       # Suu
bk(95) 
rt(90)
fd(30)
down()
circle(50,180)             # Pool ringjoonest
bgcolor("#AFEEEE")

exitonclick()

Järgnevalt esitame näite, mis joonistab ette antud pikkusega ja värviga tähe. Esitatud programmis on defineeritud kahe argumendiga funktsioon täht(pikkus, värv). Näiteks kollase tähe joonistamiseks pikkusega 100 pikslit kirjutame täht(100, "yellow").

Näiteprogramm. Täht

from turtle import *

# Defineerime funktsiooni täht, mis joonistab valitud värvi ja pikkusega tähe
def täht(pikkus, värv):    
    color(värv)
    begin_fill()                  
    i = 0
    while (i < 5):
        fd(pikkus)
        rt(144)
        i = i + 1
    end_fill()

täht(200, "yellow")        # Kilpkonn joonistab kollase tähe pikkusega 100 pikslit

exitonclick()

Ülesanne. Päikesevarjutus

Kirjutage programm, mis joonistab kilpkonna abil täielikku päikesevarjutust imiteeriva pildi. Pildi taust võiks olla musta või tumesinist värvi.

Tulemus võiks olla midagi sellist. (Tegemist ei ole kohustusliku ülesandega, aga võiksite ikka proovida.)

FUNKTSIOONID KA TKINTERIGA

Üleeelmisel nädalal tegelesime graafikaga ka mooduli Tkinter abil. Siingi saame ise funktsioone defineerida. Teeme näiteks programmi, millega saab kuusiku joonistada. Kuused koosnevad täisnurksetest kolmnurkadest. Defineerime kolm funktsiooni.

Funktsioon joonista_tase joonistab kuuse ühe taseme - täisnurkse kolmnurga, mis on määratud ülatipu ja selle vastaskülje pikkusega (taseme laius). Argumentideks on ülatipu koordinaadid, laius ja värv.
Funktsioon joonista_kuusk joonistab kuuse. Argumentideks on ladva koordinaadid, kuuse laius ja tasemete arv. Kui värvi ei märgita, siis vaikimisi joonistatakse roheline kuusk. Teistvärvi kuuse tegemiseks tuleb värv ette anda, nt joonista_kuusk(200, 50, 40, 4, "red").
Funktsioon joonista_mets joonistab argumendina antud arvu kuuski. Iga kuuse asukoht, tasemete arv ja laius on teatud piirides juhuslikud.

Näiteprogramm. Kuusik

from tkinter import *
from random import *

def joonista_tase(ülatipp_x, ülatipp_y, laius, värv):
    tahvel.create_polygon(ülatipp_x, ülatipp_y, ülatipp_x + laius/2, ülatipp_y + laius/2, ülatipp_x - laius/2,  ülatipp_y + laius/2, fill=värv, outline=värv)

def joonista_kuusk(ladva_x, ladva_y, laius, tasemeid, värv="green"):
    for tase in range(tasemeid):
        joonista_tase(ladva_x, ladva_y + tase * laius/3, laius, värv)

def joonista_mets(kuuskede_arv):
    for tase in range(kuuskede_arv):
        joonista_kuusk(randint(1, 600), randint(1, 200), randint(10, 30), randint(3, 5))

raam = Tk()
# nimeks Kuusik
raam.title("Kuusik")
# loome tahvli laiusega 600px ja kõrgusega 300 px
tahvel = Canvas(raam, width=600, height=300)

joonista_mets(10)
joonista_kuusk(200, 50, 40, 4, "red")

# paigutame tahvli raami ja teeme nähtavaks
tahvel.pack()
# siseneme põhitsüklisse
raam.mainloop()

Näiteprogramm. Miiniotsija

Lõpetuseks video miiniotsija mängu tegemisest.

< eelmine

6. nädala sisukord

järgmine >

MOOC Programmeerimise alused 2018/19 sügis