Żółwie to roboty edukacyjne, które opracowano w końcu lat czterdziestych XX wieku i które są używane do nauki informatyki.

Urządzenia te są tradycyjnie budowane z niskim zawieszeniem ze skorupą w formie półkuli, która czasem jest przezroczysta, oraz z mocnym napędem umożliwiającym ostre skręty. Roboty te są często wyposażane w różne czujniki, aby wspomóż je przy unikaniu przeszkód, oraz przy bardziej skomplikowanych konstrukcjach czujniki te pozwalają takim robotom na orientowanie się w środowisku.

W latach 80-tych XX wieku w szkołach na informatyce był nauczany język Logo, w którym możliwe było sterowanie poruszaniem się robota-żółwia. Żółw posiadał opuszczany i podnoszony pisak, którym mógł rysować linie w trakcie wykonywania swoich ruchów. I tak powstała grafika żółwia (ang. turtle graphics).

W języku Python utworzono moduł o nazwie turtle (żółw), w którym znajdują się funkcje sterujące graficznym odpowiednikiem robota-żółwia. Moduł ten jest instalowany wraz z językiem Python. Aby uzyskać dostęp do funkcji modułu musimy go najpierw zaimportować. Można to zrobić na kilka sposobów, które krótko opiszemy (opis odnosi się do wszystkich modułów Pythona).

Na początku programu umieszczamy polecenie:

import nazwa_modułu

Od tego momentu dostęp do funkcji modułu następuje przez:

nazwa_modułu.nazwa_funkcji(parametry)

Uruchom środowisko IDLE. Zapisz program na dysku w przygotowanym wcześniej katalogu. Uruchom poniższy program:

# Grafika żółwia
#---------------

# importujemy moduł turtle
import turtle

# ruszamy żółwiem naprzód 200 kroków
turtle.forward(200)

# obracamy żółwia w lewo o 90 stopni
turtle.left(90)

# idziemy żółwiem naprzód 100 kroków
turtle.forward(100)

W efekcie pojawi się okno graficzne, a w nim zobaczysz ślad zostawiony przez żółwia:

Strzałka na końcu linii symbolizuje żółwia.

Jeśli znudziło cię pisanie nazwy modułu przy każdej funkcji, to zmień polecenie importu następująco:

import turtle as t

Od tego momentu dostęp do funkcji modułu będziesz miał poprzez t.nazwa_funkcji( ). Pozmieniaj odpowiednio program:

# Grafika żółwia
#---------------

# importujemy moduł turtle jako t
import turtle as t

# ruszamy żółwiem naprzód 200 kroków
t.forward(200)

# obracamy żółwia w lewo o 90 stopni
t.left(90)

# idziemy żółwiem naprzód 100 kroków
t.forward(100)

Jeśli jesteśmy pewni, że nazwy funkcji w module turtle nie wejdą w konflikt z nazwami innych funkcji w programie, to możemy jeszcze bardziej uprościć ich wywoływanie poprzez:

from nazwa_modułu import *

Gwiazdka * za import oznacza, iż należy zaimportować wszystko z modułu. Teraz funkcje modułu stają się bezpośrednio dostępne:

# Grafika żółwia
#---------------

# importujemy moduł turtle jako t
from turtle import *

# ruszamy żółwiem naprzód 200 kroków
forward(200)

# obracamy żółwia w lewo o 90 stopni
left(90)

# idziemy żółwiem naprzód 100 kroków
forward(100)

Podsumowanie

Zaimportuj moduł turtle poleceniem:

from turtle import *

Kształt żółwia można zmieniać przy pomocy funkcji shape(...). Parametrem jest nazwa angielska kształtu:

# Grafika żółwia
#---------------

# importujemy wszystko z turtle
from turtle import *

shape("turtle")

Powrót do standardowego kształtu następuje po przesłaniu nazwy (jeśli nie zmieniałeś kształtu żółwia, to nie musisz tego umieszczać w swoim programie, bo taki kształt żółw przyjmuje standardowo):

# Grafika żółwia
#---------------

# importujemy wszystko z turtle
from turtle import *

shape("classic")

Wbudowane kształty żółwia

Argument	Kształt
"classic"	Standardowy:
"turtle	Żółw:
"arrow:	Strzałka:
"cirle"	Koło:
"square"	Kwadrat:
"triangle"	Trójkąt:

Ruch żółwia wywołują funkcje:

forward(kroki) lub fd(kroki)

Żółw porusza się w kierunku wskazywanym przez jego głowę na zadaną odległość. Jeśli ma opuszczony pisak, to rysuje ślad swojego ruchu. Niektóre funkcje posiadają nazwy skrócone: forward(...) → fd(...). Obie nazwy są tą samą funkcją. Parametr kroki może być liczbą ułamkową, czyli rzeczywistą. Wartość ujemna oznacza ruch do tyłu.

backward(kroki) lub back(kroki) lub bk(kroki)

Żółw cofa się w kierunku przeciwnym do jego głowy na zadaną odległość. Jeśli ma opuszczony pisak, to rysuje ślad swojego ruchu. Parametr kroki może być liczbą ułamkową, czyli rzeczywistą. Wartość ujemna oznacza ruch do przodu.

left(kąt) lub lt(kąt)

Żółw obraca się o zadany kąt w lewo. Kąt jest w stopniach.

right(kąt) lub rt(kąt)

Żółw obraca się o zadany kąt w prawo. Kąt jest w stopniach.

Wpisz poniższy program:

# Grafika żółwia
#---------------

from turtle import *

fd(200)
lt(90)

fd(200)
lt(90)

fd(200)
lt(90)

fd(200)
lt(90)

Efektem wykonania stanie się kwadrat o boku 200 kroków żółwia:

Program składa się z 4 grup funkcji fd(200) i lt(90). Każda z nich rysuje jeden bok kwadratu, po czym nakierowuje żółwia na kierunek następnego boku. Zamiast wpisywać je 4 razy w program, utwórzmy pętlę o czterech obiegach:

# Grafika żółwia
#---------------

from turtle import *

for i in range(4):
    fd(200)
    lt(90)

Teraz utwórzmy funkcję rysującą kwadrat o zadanym boku i wypróbujmy jej działanie:

# Grafika żółwia
#---------------

from turtle import *

def kw(bok):
    for i in range(4):
        fd(bok)
        lt(90)

kw(200)
kw(150)
kw(100)
kw(50)

Otrzymasz wynik:

Można przyspieszyć szybkość pracy żółwia funkcją speed(...). Parametrem jest liczba od 1 (najwolniej) do 10 (najszybciej).

Utwórzmy pętlę wykonującą się 36 razy, w której znajdą się te cztery wywołania funkcji kw(...). Na końcu obróćmy żółwia o kąt 10°. W ten sposób żółw zacznie rysować kwadraty coraz bardziej obrócone:

# Grafika żółwia
#---------------

from turtle import *

def kw(bok):
    for i in range(4):
        fd(bok)
        lt(90)

speed(10)

for i in range(36):
    kw(200)
    kw(150)
    kw(100)
    kw(50)
    lt(10)

Powstanie ładna rozetka:

Linia rysowana przez żółwia może mieć określoną grubość oraz kolor:

width(grubość) lub pensize(grubość)

Ustawia grubość linii, funkcja występuje pod dwoma nazwami.

color("kolor")

Funkcja ustawia kolor rysowanej linii. Kolor może być przekazywany w różny sposób, tutaj użyjemy tekstu z nazwą koloru. Nazw jest bardzo dużo, zatem najlepiej zajrzeć do dokumentacji. Oto kilka kolorów:

Funkcje te wywołujemy przed rysowaniem linii, której grubość i kolor chcemy zmienić. Uruchom poniższy program:

# Grafika żółwia
#---------------

from turtle import *

def kw(bok):
    for i in range(4):
        fd(bok)
        lt(90)

speed(10)
for i in range(36):
    width(6)
    color("red")
    kw(200)
    width(4)
    color("green")
    kw(150)
    width(2)
    color("blue")
    kw(100)
    width(1)
    color("black")
    kw(50)
    lt(10)

W ramach ćwiczenia napisz funkcję tr(bok), która rysuje trójkąt równoboczny o zadanym boku i zastąp jej wywołaniami wywołania funkcji kw(bok). W kwadracie po narysowaniu boku żółw był obracany w lewo o 90 stopni. W trójkącie żółwia należy obracać o kąt 120 stopni (dlaczego?).

Fraktal jest słowem pochodzenia łacińskiego: fractus = cząstkowy. W grafice oznacza obiekt zbudowany z elementów, które są do niego podobne. Brzmi to skomplikowanie, zatem przyjrzyjmy się przykładowi. Utwórz program:

# Fraktale
#---------

from turtle import *

def frac(b,p):
    if p == 0:
        fd(b)

speed(10)
ht() # ukrycie żółwia
pu() # piórko w górę
bk(300) # wstecz
pd() # piórko w dół
frac(600,0) # fraktal 0

Program ten rysuje pewien fraktal. Na najniższym poziomie 0 składa się on tylko z prostego odcinka o długości 600 kroków żółwia:

poziom 0

Modyfikujemy program, aby utworzyć fraktal wyższego poziomu.

# Fraktale
#---------

from turtle import *

def frac(b,p):
    if p == 0:
        fd(b)
    else:
        b /= 3
        p -= 1
        frac(b,p)
        lt(60)
        frac(b,p)
        rt(120)
        frac(b,p)
        lt(60)
        frac(b,p)
        

speed(10)
ht() # ukrycie żółwia
pu() # piórko w górę
bk(300) # wstecz
pd() # piórko w dół
frac(600,1) # fraktal 1

Na poziomie 1 fraktal zbudowany jest z czterech odcinków  o długości równej ¹/₃ długości odcinka poziomu 0. Odcinki te są ze sobą połączone następująco:

poziom 1

Na poziomie 2 każdy odcinek zastępowany jest fraktalem poziomu 1.

...
speed(10)
ht() # ukrycie żółwia
pu() # piórko w górę
bk(300) # wstecz
pd() # piórko w dół
frac(600,2) # fraktal 2

poziom 2

Fraktal poziomu 3 zbudowany jest z fraktali poziomu 2 w podobny sposób, a te z kolei są zbudowane z fraktali poziomu 1...:

...
frac(600,3) # fraktal 3

poziom 3

Proces może postępować dalej. Otrzymujesz coraz bardziej skomplikowaną figurę:

poziom 4

poziom 5

poziom 6... itd.

Procedurę rysowania fraktala możemy wykorzystać do innych figur. Oto trójkąt, którego boki są fraktalami:

# Fraktale
#---------

from turtle import *

def frac(b,p):
    if p == 0:
        fd(b)
    else:
        b /= 3
        p -= 1
        frac(b,p)
        lt(60)
        frac(b,p)
        rt(120)
        frac(b,p)
        lt(60)
        frac(b,p)
        

speed(10)
ht()
pu()
bk(200)
lt(90)
fd(150)
rt(90)
pd()
for i in range(3):
    frac(400,4)
    rt(120)

poziom 4

A tutaj rozetka zbudowana na bazie powyższego fraktala:

# Fraktale
#---------

from turtle import *

def frac(b,p):
    if p == 0:
        fd(b)
    else:
        b /= 3
        p -= 1
        frac(b,p)
        lt(60)
        frac(b,p)
        rt(120)
        frac(b,p)
        lt(60)
        frac(b,p)
        
def tr_frac(b,p):
    for i in range(3):
        frac(b,p)
        rt(120)
        
speed(10)
ht()
for i in range(12):
    tr_frac(200,3)
    lt(30)

poziom 3

A oto sławny trójkąt Sierpińskiego zbudowany z trójkątów:

# Fraktale
#---------

from turtle import *

def frac(b,p):
    if p == 0:
        for i in range(3):
            fd(b)
            lt(120)
    else:
        b /= 2
        p -= 1
        frac(b,p)
        fd(b)
        frac(b,p)
        bk(b)
        lt(60)
        fd(b)
        rt(60)
        frac(b,p)
        lt(60)
        bk(b)
        rt(60)
        
speed(10)
ht()
pu()
bk(300)
rt(90)
fd(250)
lt(90)
pd()
frac(600,5)

poziom 5