turtle — Grafika żółwia

Kod źródłowy: Lib/turtle.py

Wprowadzenie

Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

Wyobraźmy sobie żółwia-robota rozpoczynającego ruch w punkcie (0, 0) na płaszczyźnie x-y. Po import turtle, wydaj polecenie turtle.forward(15), a przesunie się (na ekranie!) o 15 pikseli w kierunku, w którym jest zwrócony, rysując linię podczas ruchu. Wydaj polecenie turtle.right(25), a obróci się w miejscu o 25 stopni zgodnie z ruchem wskazówek zegara.

By combining together these and similar commands, intricate shapes and pictures can easily be drawn.

The turtle module is an extended reimplementation of the same-named module from the Python standard distribution up to version Python 2.5.

It tries to keep the merits of the old turtle module and to be (nearly) 100% compatible with it. This means in the first place to enable the learning programmer to use all the commands, classes and methods interactively when using the module from within IDLE run with the -n switch.

The turtle module provides turtle graphics primitives, in both object-oriented and procedure-oriented ways. Because it uses tkinter for the underlying graphics, it needs a version of Python installed with Tk support.

The object-oriented interface uses essentially two+two classes:

  1. The TurtleScreen class defines graphics windows as a playground for the drawing turtles. Its constructor needs a tkinter.Canvas or a ScrolledCanvas as argument. It should be used when turtle is used as part of some application.

    The function Screen() returns a singleton object of a TurtleScreen subclass. This function should be used when turtle is used as a standalone tool for doing graphics. As a singleton object, inheriting from its class is not possible.

    All methods of TurtleScreen/Screen also exist as functions, i.e. as part of the procedure-oriented interface.

  2. RawTurtle (alias: RawPen) defines Turtle objects which draw on a TurtleScreen. Its constructor needs a Canvas, ScrolledCanvas or TurtleScreen as argument, so the RawTurtle objects know where to draw.

    Derived from RawTurtle is the subclass Turtle (alias: Pen), which draws on „the” Screen instance which is automatically created, if not already present.

    All methods of RawTurtle/Turtle also exist as functions, i.e. part of the procedure-oriented interface.

The procedural interface provides functions which are derived from the methods of the classes Screen and Turtle. They have the same names as the corresponding methods. A screen object is automatically created whenever a function derived from a Screen method is called. An (unnamed) turtle object is automatically created whenever any of the functions derived from a Turtle method is called.

To use multiple turtles on a screen one has to use the object-oriented interface.

Informacja

W poniższej dokumentacji podano listę argumentów dla funkcji. Metody, oczywiście, mają dodatkowy pierwszy argument self, który jest tutaj pominięty.

Overview of available Turtle and Screen methods

Metody żółwia

Ruch żółwia
Przesuwanie i rysowanie
forward() | fd()
backward() | bk() | back()
right() | rt()
left() | lt()
goto() | setpos() | setposition()
setx()
sety()
setheading() | seth()
home()
circle()
dot()
stamp()
clearstamp()
clearstamps()
undo()
speed()
Pobieranie stanu żółwia
position() | pos()
towards()
xcor()
ycor()
heading()
distance()
Ustawienia i pomiary
degrees()
radians()
Kontrola pióra
Stan rysowania
pendown() | pd() | down()
penup() | pu() | up()
pensize() | width()
pen()
isdown()
Kontrola koloru
color()
pencolor()
fillcolor()
Wypełnienie
filling()
begin_fill()
end_fill()
Więcej kontroli rysowania
reset()
clear()
write()
Stan żółwia
Widoczność
showturtle() | st()
hideturtle() | ht()
isvisible()
Wygląd
shape()
resizemode()
shapesize() | turtlesize()
shearfactor()
settiltangle()
tiltangle()
tilt()
shapetransform()
get_shapepoly()
Korzystanie ze zdarzeń
onclick()
onrelease()
ondrag()
Specjalne metody żółwi
begin_poly()
end_poly()
get_poly()
clone()
getturtle() | getpen()
getscreen()
setundobuffer()
undobufferentries()

Metody TurtleScreen/Screen

Kontrola okna
bgcolor()
bgpic()
clearscreen()
resetscreen()
screensize()
setworldcoordinates()
Kontrola animacji
delay()
tracer()
update()
Korzystanie ze zdarzeń ekranowych
listen()
onkey() | onkeyrelease()
onkeypress()
onclick() | onscreenclick()
ontimer()
mainloop() | done()
Ustawienia i metody specjalne
mode()
colormode()
getcanvas()
getshapes()
register_shape() | addshape()
turtles()
window_height()
window_width()
Metody wprowadzania danych
textinput()
numinput()
Metody specyficzne dla klasy Screen
bye()
exitonclick()
setup()
title()

Metody RawTurtle/Turtle i odpowiadające im funkcje

Większość przykładów w tej sekcji odnosi się do instancji klasy Turtle o nazwie turtle.

Ruch żółwia

turtle.forward(distance)
turtle.fd(distance)
Parametry

distance – liczba (całkowita lub zmiennoprzecinkowa)

Przesuwa żółwia do przodu o określony dystans, w kierunku, w którym żółw jest skierowany.

>>> turtle.position()
(0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)
Parametry

distance – liczba

Przesuwa żółwia do tyłu o dystans, w kierunku przeciwnym do kierunku, w którym żółw jest skierowany. Nie zmienia kierunku żółwia.

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.right(angle)
turtle.rt(angle)
Parametry

angle – liczba (całkowita lub zmiennoprzecinkowa)

Obraca żółwia w prawo o jednostki kąta. (Jednostki to domyślnie stopnie, ale można je ustawić za pomocą funkcji degrees() i radians().) Orientacja kąta zależy od trybu żółwia, patrz mode().

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
turtle.left(angle)
turtle.lt(angle)
Parametry

angle – liczba (całkowita lub zmiennoprzecinkowa)

Obraca żółwia w lewo o jednostki kąta. (Jednostki to domyślnie stopnie, ale można je ustawić za pomocą funkcji degrees() i radians().) Orientacja kąta zależy od trybu żółwia, patrz mode().

>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
Parametry

  • x – liczba lub para/wektor liczb

  • y – liczba lub None

Jeśli y to None, x musi być parą współrzędnych lub obiektem Vec2D (np. zwróconym przez pos()).

Przesuwa żółwia do pozycji bezwzględnej. Jeśli pióro jest opuszczone, rysuje linię. Nie zmienia orientacji żółwia.

 >>> tp = turtle.pos()
 >>> tp
 (0.00,0.00)
 >>> turtle.setpos(60,30)
 >>> turtle.pos()
 (60.00,30.00)
 >>> turtle.setpos((20,80))
 >>> turtle.pos()
 (20.00,80.00)
 >>> turtle.setpos(tp)
 >>> turtle.pos()
 (0.00,0.00)
turtle.setx(x)
Parametry

x – liczba (całkowita lub zmiennoprzecinkowa)

Ustawia pierwszą współrzędną żółwia na x, drugą pozostawiając bez zmian.

>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)
turtle.sety(y)
Parametry

y – liczba (całkowita lub zmiennoprzecinkowa)

Ustawia drugą współrzędną żółwia na y, pozostawiąc pierwszą współrzędną bez zmian.

>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)
turtle.setheading(to_angle)
turtle.seth(to_angle)
Parametry

to_angle – liczba (całkowita lub zmiennoprzecinkowa)

Ustawia orientację żółwia na to_angle. Oto kilka często używanych kierunków w stopniach:

tryb standardowy

tryb logo

0 – wschód

0 – północ

90 – północ

90 – wschód

180 – zachód

180 – południe

270 – południe

270 – zachód

 
>>> turtle.setheading(90)
>>> turtle.heading()
90.0
turtle.home()

Przesuwa żółwia do punktu początkowego – współrzędne (0,0) – i ustawia jego kurs na orientację początkową (która zależy od trybu, patrz mode()).

>>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.circle(radius, extent=None, steps=None)
Parametry

  • radius – liczba

  • extent – liczba (lub None)

  • steps – liczba całkowita (lub None)

Rysuje okrąg o podanym promieniu. Środek znajduje się w odległości radius na lewo od żółwia; extent – kąt – określa, która część okręgu zostanie narysowana. Jeśli extent nie jest podany, rysowany jest cały okrąg. Jeśli extent nie jest pełnym okręgiem, jednym z punktów końcowych łuku jest bieżąca pozycja pióra. Rysuje łuk w kierunku przeciwnym do ruchu wskazówek zegara, jeśli radius jest dodatni, w przeciwnym razie w kierunku zgodnym z ruchem wskazówek zegara. Kierunek żółwia jest zmieniany o wartość extent.

Ponieważ okrąg jest przybliżany przez wpisany wielokąt foremny, steps określa liczbę kroków do użycia. Jeśli nie zostanie podana, zostanie obliczona automatycznie. Może być używana do rysowania wielokątów foremnych.

>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
>>> turtle.heading()
180.0
turtle.dot(size=None, *color)
Parametry

  • size – liczba całkowita >= 1 (jeśli podano)

  • color – colorstring lub numeryczna krotka koloru

Rysuje okrągłą kropkę o średnicy size, używając koloru color. Jeśli nie podano size, używana jest maksymalna wartość z pensize+4 i 2*pensize.

>>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
(100.00,-0.00)
>>> turtle.heading()
0.0
turtle.stamp()

Stempluje kopię kształtu żółwia na płótnie w bieżącej pozycji żółwia. Zwraca stamp_id dla tego stempla, który może być użyty do usunięcia go przez wywołanie clearstamp(stamp_id).

>>> turtle.color("blue")
>>> turtle.stamp()
11
>>> turtle.fd(50)
turtle.clearstamp(stampid)
Parametry

stampid – liczba całkowita, musi być wartością zwróconą przez wywołanie poprzedniego stamp()

Usunięcie stempla z podanym stampid.

>>> turtle.position()
(150.00,-0.00)
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.position()
(200.00,-0.00)
>>> turtle.clearstamp(astamp)
>>> turtle.position()
(200.00,-0.00)
turtle.clearstamps(n=None)
Parametry

n – liczba całkowita (lub None)

Usuwa wszystkie lub pierwsze/ostatnie n stempli żółwia. Jeśli n to None, usuwa wszystkie stemple, jeśli n > 0 usuwa pierwsze n stempli, inaczej jeśli n < 0 usuwa ostatnie n stempli.

>>> for i in range(8):
...     turtle.stamp(); turtle.fd(30)
13
14
15
16
17
18
19
20
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

Cofa (wielokrotnie) ostatnią akcję (akcje) żółwia. Liczba dostępnych cofnięć zależy od rozmiaru bufora cofania.

>>> for i in range(4):
...     turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
...     turtle.undo()
turtle.speed(speed=None)
Parametry

speed – liczba całkowita w zakresie 0..10 lub nazwa prędkości (patrz poniżej)

Ustawia prędkość żółwia na wartość liczby całkowitej w zakresie 0..10. Jeśli nie podano argumentu, zwraca aktualną prędkość.

Jeśli wartość wejściowa jest większa niż 10 lub mniejsza niż 0,5, prędkość jest ustawiana na 0. Nazwy prędkości są mapowane na wartości prędkości w następujący sposób:

  • „fastest”: 0

  • „fast”: 10

  • „normal”: 6

  • „slow”: 3

  • „slowest”: 1

Prędkości od 1 do 10 wymuszają coraz szybszą animację rysowania linii i obracania żółwia.

Uwaga: speed = 0 oznacza, że żadna animacja nie ma miejsca. forward/back sprawia, że żółw skacze i podobnie left/right sprawia, że żółw natychmiast się obraca.

>>> turtle.speed()
3
>>> turtle.speed('normal')
>>> turtle.speed()
6
>>> turtle.speed(9)
>>> turtle.speed()
9

Pobieranie stanu żółwia

turtle.position()
turtle.pos()

Zwraca bieżącą lokalizację żółwia (x,y) (jako wektor Vec2D).

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
Parametry

  • x – liczba lub para/wektor liczb lub instancja żółwia

  • y – liczba, jeśli x jest liczbą, w przeciwnym razie None

Zwraca kąt między linią od pozycji żółwia do pozycji określonej przez (x,y), wektor lub drugiego żółwia. Zależy to od orientacji początkowej żółwia, która zależy od trybu – „standard”/„world” lub „logo”.

>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
turtle.xcor()

Zwraca współrzędną x żółwia.

>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
(64.28,76.60)
>>> print(round(turtle.xcor(), 5))
64.27876
turtle.ycor()

Zwraca współrzędną y żółwia.

>>> turtle.home()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print(turtle.pos())
(50.00,86.60)
>>> print(round(turtle.ycor(), 5))
86.60254
turtle.heading()

Zwraca aktualny kierunek żółwia (wartość zależy od trybu żółwia, patrz mode()).

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
turtle.distance(x, y=None)
Parametry

  • x – liczba lub para/wektor liczb lub instancja żółwia

  • y – liczba, jeśli x jest liczbą, w przeciwnym razie None

Zwraca odległość od żółwia do (x,y), podanego wektora lub podanego innego żółwia, w jednostkach kroku żółwia.

>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0

Ustawienia pomiarowe

turtle.degrees(fullcircle=360.0)
Parametry

fullcircle – liczba

Ustawia jednostki pomiaru kąta, tj. liczbę „stopni” dla pełnego okręgu. Domyślna wartość to 360 stopni.

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0

Change angle measurement unit to grad (also known as gon,
grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100.0
>>> turtle.degrees(360)
>>> turtle.heading()
90.0
turtle.radians()

Ustawia jednostki miary kąta na radiany. Odpowiednik degrees(2*math.pi).

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966

Kontrola pióra

Stan rysowania

turtle.pendown()
turtle.pd()
turtle.down()

Opuszcza pióro w dół – rysowanie podczas ruchu.

turtle.penup()
turtle.pu()
turtle.up()

Podnosi pióro do góry – nierysowanie podczas ruchu.

turtle.pensize(width=None)
turtle.width(width=None)
Parametry

width – liczba dodatnia

Ustawia grubość linii na width lub zwraca ją. Jeśli resizemode jest ustawiony na „auto”, a turtleshape jest wielokątem, wielokąt ten jest rysowany z taką samą grubością linii. Jeśli nie podano argumentu, zwracany jest bieżący rozmiar pióra.

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
turtle.pen(pen=None, **pendict)
Parametry

  • pen – słownik z niektórymi lub wszystkimi z poniższych kluczy

  • pendict – jedno lub więcej argumentów nazwanych z poniższymi kluczami jako nazwami

Zwraca lub ustawia atrybuty pióra w „pióro-słowniku” z następującymi parami klucz/wartość:

  • „shown”: True/False

  • „pendown”: True/False

  • „pencolor”: nazwa koloru (color-string) lub kolor-krotka

  • „fillcolor”: nazwa koloru (color-string) lub kolor-krotka

  • „pensize”: liczba dodatnia

  • „speed”: liczba z przedziału 0..10

  • „resizemode”: „auto” lub „user” lub „noresize”

  • „stretchfactor”: (liczba dodatnia, liczba dodatnia)

  • „outline”: liczba dodatnia

  • „tilt”: liczba

Ten słownik może być użyty jako argument dla kolejnego wywołania pen() w celu przywrócenia poprzedniego stanu pióra. Co więcej, jeden lub więcej z tych atrybutów może być przekazany jako argument nazwany. Można to wykorzystać do ustawienia kilku atrybutów pióra w jednej instrukcji.

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> sorted(turtle.pen().items())
[('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'),
 ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'),
 ('shearfactor', 0.0), ('shown', True), ('speed', 9),
 ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
>>> penstate=turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', ''), ('outline', 1), ('pencolor', 'yellow')]
>>> turtle.pen(penstate, fillcolor="green")
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', 'green'), ('outline', 1), ('pencolor', 'red')]
turtle.isdown()

Zwraca True jeśli pióro jest opuszczone, False jeśli jest podniesione.

>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True

Kontrola koloru

turtle.pencolor(*args)

Zwraca lub ustawia kolor pióra.

Dozwolone są cztery formaty wejściowe:

pencolor()

Zwraca bieżący kolor pióra jako ciąg specyfikacji koloru lub jako krotkę (patrz przykład). Może być użyty jako dane wejściowe do innego wywołania color/pencolor/fillcolor.

pencolor(colorstring)

Ustawia kolor pióra na colorstring, który jest ciągiem specyfikacji koloru Tk, takim jak "red", "yellow", lub "#33cc8c".

pencolor((r, g, b))

Ustawia kolor pióra na kolor RGB reprezentowany przez krotkę r, g i b. Każda z r, g i b musi należeć do zakresu 0..colormode, gdzie colormode to 1.0 lub 255 (patrz colormode()).

pencolor(r, g, b)

Ustawia kolor pióra na kolor RGB reprezentowany przez r, g i b. Każda z r, g i b musi należeć do zakresu 0..colormode.

Jeśli turtleshape jest wielokątem, kontur tego wielokąta jest rysowany przy użyciu nowo ustawionego koloru pióra.

 >>> colormode()
 1.0
 >>> turtle.pencolor()
 'red'
 >>> turtle.pencolor("brown")
 >>> turtle.pencolor()
 'brown'
 >>> tup = (0.2, 0.8, 0.55)
 >>> turtle.pencolor(tup)
 >>> turtle.pencolor()
 (0.2, 0.8, 0.5490196078431373)
 >>> colormode(255)
 >>> turtle.pencolor()
 (51.0, 204.0, 140.0)
 >>> turtle.pencolor('#32c18f')
 >>> turtle.pencolor()
 (50.0, 193.0, 143.0)
turtle.fillcolor(*args)

Zwraca lub ustawia kolor wypełnienia.

Dozwolone są cztery formaty wejściowe:

fillcolor()

Zwraca bieżący kolor wypełnienia jako ciąg specyfikacji koloru, ewentualnie w formacie krotki (patrz przykład). Może być użyty jako dane wejściowe do innego wywołania color/pencolor/fillcolor.

fillcolor(colorstring)

Ustawia kolor wypełnienia na colorstring, który jest ciągiem specyfikacji koloru Tk, takim jak "red", "yellow", lub "#33cc8c".

fillcolor((r, g, b))

Ustawia kolor wypełnienia na kolor RGB reprezentowany przez krotkę r, g i b. Każdy z r, g i b musi należeć do zakresu 0..colormode, gdzie colormode to 1.0 lub 255 (patrz colormode()).

fillcolor(r, g, b)

Ustawia kolor wypełnienia na kolor RGB reprezentowany przez r, g i b. Każde z r, g i b musi należeć do zakresu 0..colormode.

Jeśli turtleshape jest wielokątem, wnętrze tego wielokąta jest rysowane z nowo ustawionym kolorem wypełnienia.

 >>> turtle.fillcolor("violet")
 >>> turtle.fillcolor()
 'violet'
 >>> turtle.pencolor()
 (50.0, 193.0, 143.0)
 >>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
 >>> turtle.fillcolor()
 (50.0, 193.0, 143.0)
 >>> turtle.fillcolor('#ffffff')
 >>> turtle.fillcolor()
 (255.0, 255.0, 255.0)
turtle.color(*args)

Zwraca lub ustawia kolor pióra i wypełnienia.

Dozwolonych jest kilka formatów wejściowych. Używają one od 0 do 3 argumentów w następujący sposób:

color()

Zwraca bieżący kolor pióra i bieżący kolor wypełnienia jako parę ciągów specyfikacji kolorów lub krotek zwracanych przez pencolor() i fillcolor().

color(colorstring), color((r,g,b)), color(r,g,b)

Dane wejściowe jak w pencolor(), ustawiają zarówno kolor wypełnienia, jak i kolor pióra na podaną wartość.

color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2))

Odpowiednik dla pencolor(colorstring1) i fillcolor(colorstring2) oraz analogicznie, jeśli używany jest inny format wejścia.

Jeśli turtleshape jest wielokątem, kontur i wnętrze tego wielokąta są rysowane z nowo ustawionymi kolorami.

 >>> turtle.color("red", "green")
 >>> turtle.color()
 ('red', 'green')
 >>> color("#285078", "#a0c8f0")
 >>> color()
 ((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))

Zobacz także: Metoda klasy Screen colormode().

Wypełnienie

turtle.filling()

Zwraca fillstate (True jeśli wypełnienie, False w przeciwnym razie).

 >>> turtle.begin_fill()
 >>> if turtle.filling():
 ...    turtle.pensize(5)
 ... else:
 ...    turtle.pensize(3)
turtle.begin_fill()

Do wywołania tuż przed rysowaniem kształtu do wypełnienia.

turtle.end_fill()

Wypełnia kształt narysowany po ostatnim wywołaniu begin_fill().

To, czy obszary nakładania się przecinających się wielokątów lub wielu kształtów są wypełnione, zależy od grafiki systemu operacyjnego, typu nakładania się i liczby nakładających się obszarów. Na przykład żółwiowa gwiazda na górze rozdziału może być cała żółta lub mieć kilka białych obszarów.

>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()

Więcej kontroli rysowania

turtle.reset()

Usuń rysunki żółwia z ekranu, ponownie wyśrodkuj żółwia i ustaw zmienne na wartości domyślne.

>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.clear()

Usuwa rysunki żółwia z ekranu. Nie rusza żółwia. Stan i pozycja żółwia, a także rysunki innych żółwi, nie zostaną zmienione.

turtle.write(arg, move=False, align='left', font=('Arial', 8, 'normal'))
Parametry

  • arg – obiekt, który ma zostać zapisany na TurtleScreen

  • move – True/False

  • align – jedna z wartości „left”, „center” lub „right”

  • font – trójka wartości (fontname, fontsize, fonttype)

Pisze tekst – reprezentację obiektu arg – w bieżącej pozycji żółwia zgodnie z align („left”, „center” lub „right”) i z podaną czcionką. Jeśli move to True, pióro jest przesuwane do prawego dolnego rogu tekstu. Domyślnie move ma wartość False.

>>> turtle.write("Home = ", True, align="center")
>>> turtle.write((0,0), True)

Stan żółwia

Widoczność

turtle.hideturtle()
turtle.ht()

Czyni żółwia niewidocznym. Dobrym pomysłem jest zrobienie tego w trakcie wykonywania złożonego rysunku, ponieważ ukrycie żółwia znacznie przyspiesza rysowanie.

>>> turtle.hideturtle()
turtle.showturtle()
turtle.st()

Sprawia, że żółw jest widoczny.

>>> turtle.showturtle()
turtle.isvisible()

Zwraca True jeśli żółw jest widoczny, False jeśli jest ukryty.

>>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True

Wygląd

turtle.shape(name=None)
Parametry

name – ciąg znaków, który jest prawidłową nazwą kształtu

Ustawia kształt żółwia na kształt o podanej nazwie name lub, jeśli nazwa nie została podana, zwraca nazwę bieżącego kształtu. Kształt o nazwie name musi istnieć w słowniku kształtów TurtleScreen. Początkowo dostępne są następujące kształty wielokątów: „arrow”, „turtle”, „circle”, „square”, „triangle”, „classic”. Aby dowiedzieć się, jak radzić sobie z kształtami, zobacz metodę Screen register_shape().

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
turtle.resizemode(rmode=None)
Parametry

rmode – jeden z ciągów znaków „auto”, „user”, „noresize”

Ustawia tryb zmiany rozmiaru na jedną z wartości: „auto”, „user”, „noresize”. Jeśli nie podano rmode, zwraca bieżący tryb zmiany rozmiaru. Różne tryby zmiany rozmiaru mają następujące skutki:

  • „auto”: dostosowuje wygląd żółwia do wartości rozmiaru pióra.

  • „user”: dostosowuje wygląd żółwia zgodnie z wartościami stretchfactor i outlinewidth (outline), które są ustawiane przez shapesize().

  • „noresize”: nie następuje adaptacja wyglądu żółwia.

resizemode("user") jest wywoływana przez shapesize(), gdy jest użyte z argumentami.

>>> turtle.resizemode()
'noresize'
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
'auto'
turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)
turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)
Parametry

  • stretch_wid – liczba dodatnia

  • stretch_len – liczba dodatnia

  • outline – liczba dodatnia

Zwraca lub ustawia współczynniki x/y rozciągnięcia i/lub konturu pióra. Ustawia tryb zmiany rozmiaru na „user”. Wtedy i tylko wtedy, gdy resizemode jest ustawione na „user”, żółw będzie wyświetlany rozciągnięty zgodnie ze swoimi współczynnikami rozciągnięcia: stretch_wid to współczynnik rozciągnięcia prostopadły do jego orientacji, stretch_len to współczynnik rozciągnięcia w kierunku jego orientacji, outline określa szerokość obrysu kształtu.

>>> turtle.shapesize()
(1.0, 1.0, 1)
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize()
(5, 5, 12)
>>> turtle.shapesize(outline=8)
>>> turtle.shapesize()
(5, 5, 8)
turtle.shearfactor(shear=None)
Parametry

shear – liczba (opcjonalna)

Ustawia lub zwraca bieżący współczynnik odchylenia. Odchyla kształt żółwia zgodnie z podanym współczynnikiem, który jest tangensem kąta odchylenia. Nie zmienia kursu żółwia (kierunku ruchu). Jeśli nie podano współczynnika: zwraca aktualny współczynnik odchylenia, tj. tangens kąta odchylenia, o który odchylają się linie równoległe do kierunku ruchu żółwia.

 >>> turtle.shape("circle")
 >>> turtle.shapesize(5,2)
 >>> turtle.shearfactor(0.5)
 >>> turtle.shearfactor()
 0.5
turtle.tilt(angle)
Parametry

angle – liczba

Obróć żółwia o kąt w stosunku do jego aktualnego kąta nachylenia, ale nie zmieniaj jego kursu (kierunku ruchu).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
turtle.settiltangle(angle)
Parametry

angle – liczba

Rotate the turtleshape to point in the direction specified by angle, regardless of its current tilt-angle. Do not change the turtle’s heading (direction of movement).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> turtle.fd(50)

Niezalecane od wersji 3.1.

turtle.tiltangle(angle=None)
Parametry

angle – liczba (opcjonalna)

Ustawia lub zwraca bieżący kąt nachylenia. Jeśli podano kąt, obraca żółwia tak, aby wskazywał kierunek określony przez kąt, niezależnie od jego aktualnego kąta nachylenia. Nie zmienia kierunku żółwia (kierunku ruchu). Jeśli nie podano kąta: zwraca aktualny kąt nachylenia, tj. kąt między orientacją kształtu żółwia a jego kursem (kierunkiem ruchu).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
45.0
turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)
Parametry

  • t11 – liczba (opcjonalna)

  • t12 – liczba (opcjonalna)

  • t21 – liczba (opcjonalna)

  • t12 – liczba (opcjonalna)

Ustawia lub zwraca bieżącą macierz transformacji kształtu żółwia.

Jeśli nie podano żadnego z elementów macierzy, zwraca macierz transformacji jako krotkę 4 elementów. W przeciwnym razie ustawia podane elementy i przekształca kształt żółwia zgodnie z macierzą składającą się z pierwszego wiersza t11, t12 i drugiego wiersza t21, t22. Wyznacznik t11 * t22 - t12 * t21 nie może być równy zero, w przeciwnym razie zostanie rzucony błąd. Modyfikuje stretchfactor, shearfactor i tiltangle zgodnie z podaną macierzą.

>>> turtle = Turtle()
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
(4.0, -1.0, -0.0, 2.0)
turtle.get_shapepoly()

Zwraca bieżący wielokąt kształtu jako krotkę par współrzędnych. Może to być wykorzystane do zdefiniowania nowego kształtu lub komponentów kształtu złożonego.

>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))

Korzystanie ze zdarzeń

turtle.onclick(fun, btn=1, add=None)
Parametry

  • fun – funkcja z dwoma argumentami, która zostanie wywołana ze współrzędnymi klikniętego punktu na płótnie

  • btn – numer przycisku myszy, domyślnie 1 (lewy przycisk myszy)

  • add – True lub False – jeśli True, zostanie dodane nowe powiązanie, w przeciwnym razie zastąpi poprzednie powiązanie

Wiąże fun ze zdarzeniami kliknięcia myszą na tym żółwiu. Jeśli fun to None, istniejące powiązania są usuwane. Przykład dla anonimowego żółwia, tj. sposób proceduralny:

>>> def turn(x, y):
...     left(180)
...
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed
turtle.onrelease(fun, btn=1, add=None)
Parametry

  • fun – funkcja z dwoma argumentami, która zostanie wywołana ze współrzędnymi klikniętego punktu na płótnie

  • btn – numer przycisku myszy, domyślnie 1 (lewy przycisk myszy)

  • add – True lub False – jeśli True, zostanie dodane nowe powiązanie, w przeciwnym razie zastąpi poprzednie powiązanie

Powiąż fun ze zdarzeniami zwolnienia przycisku myszy na tym żółwiu. Jeśli fun to None, istniejące powiązania są usuwane.

>>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
...
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
turtle.ondrag(fun, btn=1, add=None)
Parametry

  • fun – funkcja z dwoma argumentami, która zostanie wywołana ze współrzędnymi klikniętego punktu na płótnie

  • btn – numer przycisku myszy, domyślnie 1 (lewy przycisk myszy)

  • add – True lub False – jeśli True, zostanie dodane nowe powiązanie, w przeciwnym razie zastąpi poprzednie powiązanie

Powiąż fun ze zdarzeniami ruchu myszy na tym żółwiu. Jeśli fun to None, istniejące powiązania są usuwane.

Uwaga: Każda sekwencja zdarzeń ruchu myszą na żółwiu jest poprzedzona zdarzeniem kliknięcia myszą na tym żółwiu.

>>> turtle.ondrag(turtle.goto)

Następnie kliknięcie i przeciągnięcie żółwia spowoduje przesunięcie go po ekranie, tworząc rysunki odręczne (jeśli pióro jest opuszczone).

Specjalne metody żółwi

turtle.begin_poly()

Rozpoczyna rejestrowanie wierzchołków wielokąta. Bieżąca pozycja żółwia to pierwszy wierzchołek wielokąta.

turtle.end_poly()

Zatrzymuje rejestrowanie wierzchołków wielokąta. Bieżąca pozycja żółwia to ostatni wierzchołek wielokąta. Zostanie on połączony z pierwszym wierzchołkiem.

turtle.get_poly()

Zwraca ostatni zarejestrowany wielokąt.

>>> turtle.home()
>>> turtle.begin_poly()
>>> turtle.fd(100)
>>> turtle.left(20)
>>> turtle.fd(30)
>>> turtle.left(60)
>>> turtle.fd(50)
>>> turtle.end_poly()
>>> p = turtle.get_poly()
>>> register_shape("myFavouriteShape", p)
turtle.clone()

Utwórz i zwróć klona żółwia z tą samą pozycją, kursem i właściwościami.

>>> mick = Turtle()
>>> joe = mick.clone()
turtle.getturtle()
turtle.getpen()

Zwraca sam obiekt Turtle. Jedyne rozsądne zastosowanie: jako funkcja do zwracania „anonimowego żółwia”:

>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>
turtle.getscreen()

Zwraca obiekt TurtleScreen, na którym żółw rysuje. Następnie można wywoływać metody TurtleScreen na tym obiekcie.

>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
turtle.setundobuffer(size)
Parametry

size – liczba całkowita lub None

Ustawia lub wyłącza undobuffer. Jeśli size jest liczbą całkowitą, instalowany jest pusty undobuffer o podanym rozmiarze. size podaje maksymalną liczbę akcji żółwia, które mogą być cofnięte przez metodę/funkcję undo(). Jeśli size to None, undobuffer jest wyłączany.

>>> turtle.setundobuffer(42)
turtle.undobufferentries()

Zwraca liczba wpisów w undobuffer.

>>> while undobufferentries():
...     undo()

Kształty złożone

Aby korzystać ze złożonych kształtów żółwia, składających się z kilku wielokątów o różnych kolorach, należy jawnie użyć klasy pomocniczej Shape, zgodnie z poniższym opisem:

  1. Utwórz pusty obiekt Shape o typie „compound”.

  2. Dodaj dowolną liczbę komponentów do tego obiektu, korzystając z metody addcomponent().

    Na przykład:

    >>> s = Shape("compound")
>>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s.addcomponent(poly1, "red", "blue")
>>> poly2 = ((0,0),(10,-5),(-10,-5))
>>> s.addcomponent(poly2, "blue", "red")

  3. Teraz dodaj obiekt Shape do listy kształtów obiektu Screen i użyj go:

    >>> register_shape("myshape", s)
>>> shape("myshape")

Informacja

Klasa Shape jest używana wewnętrznie przez register_shape() metoda na różne sposoby. Programista aplikacji powinien używać klasy Shape tylko podczas korzystania z kształtów złożonych, jak pokazano powyżej!

Metody TurtleScreen/Screen i odpowiadające im funkcje

Większość przykładów w tej sekcji odnosi się do instancji TurtleScreen o nazwie screen.

Kontrola okna

turtle.bgcolor(*args)
Parametry

args – a color string or three numbers in the range 0..colormode or a 3-tuple of such numbers

Set or return background color of the TurtleScreen.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)
turtle.bgpic(picname=None)
Parametry

picname – a string, name of a gif-file or "nopic", or None

Ustawia obraz tła lub zwraca nazwę bieżącego obrazu tła. Jeśli picname jest nazwą pliku, ustawia odpowiedni obraz jako tło. Jeśli picname to "nopic", usuwa obraz tła, o ile istnieje. Jeśli picname to None, zwraca nazwę pliku bieżącego obrazu tła.

>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
"landscape.gif"
turtle.clear()

Informacja

Ta metoda TurtleScreen jest dostępna jako globalna funkcja wyłącznie pod nazwą clearscreen. Globalna funkcja clear to inna funkcja pochodząca się z metody Turtle clear.

turtle.clearscreen()

Usuwa wszystkie rysunki i wszystkie żółwie z TurtleScreen. Przywraca pusty ekran TurtleScreen do stanu początkowego: białe tło, brak obrazu tła, brak powiązań zdarzeń oraz włączona funkcja śledzenia.

turtle.reset()

Informacja

Ta metoda TurtleScreen jest dostępna jako globalna funkcja wyłącznie pod nazwą resetscreen. Globalna funkcja reset wywodzi się z metody Turtle reset.

turtle.resetscreen()

Przywraca wszystkie obiekty Turtle na ekranie Screen do stanu początkowego.

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
Parametry

  • canvwidth – dodatnia liczba całkowita, nowa szerokość płótna w pikselach

  • canvheight – dodatnia liczba całkowita, nowa wysokość płótna w pikselach

  • bg – nazwa koloru (color-string) lub kolor-krotka, nowy kolor tła

Jeśli nie podano argumentów, zwraca aktualne (szerokość płótna, wysokość płótna). W przeciwnym razie zmienia rozmiar płótna, na którym rysują żółwie. Nie zmienia okna rysowania. Aby obejrzeć ukryte części obszaru rysowania, należy użyć pasków przewijania. Za pomocą tej metody można uwidocznić te części rysunku, które wcześniej znajdowały się poza obszarem płótna.

>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)

np. aby poszukać żółwia, który przypadkiem uciekł ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)
Parametry

  • llx – liczba, współrzędna x lewego dolnego rogu płótna

  • lly – liczba, współrzędna y lewego dolnego rogu płótna

  • urx – liczba, współrzędna x prawego górnego rogu płótna

  • ury – liczba, współrzędna y prawego górnego rogu płótna

Konfiguruje układ współrzędnych zdefiniowany przez użytkownika i w razie potrzeby przełącza do trybu „world”. Powoduje to wykonanie screen.reset(). Jeśli tryb „world” jest już aktywny, wszystkie rysunki zostaną ponownie wygenerowane zgodnie z nowymi współrzędnymi.

ATTENTION: in user-defined coordinate systems angles may appear distorted.

>>> screen.reset()
>>> screen.setworldcoordinates(-50,-7.5,50,7.5)
>>> for _ in range(72):
...     left(10)
...
>>> for _ in range(8):
...     left(45); fd(2)   # a regular octagon

Kontrola animacji

turtle.delay(delay=None)
Parametry

delay – dodatnia liczba całkowita

Ustawia lub zwraca opóźnienie rysowania w milisekundach. (Jest to w przybliżeniu odstęp czasu między dwiema kolejnymi aktualizacjami obszaru rysowania.) Im dłuższe opóźnienie rysowania, tym wolniejsza animacja.

Opcjonalny argument:

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
turtle.tracer(n=None, delay=None)
Parametry

  • n – nieujemna liczba całkowita

  • delay – nieujemna liczba całkowita

Włącza/wyłącza animację żółwia oraz ustawia opóźnienie aktualizacji rysunków. Jeśli podano wartość n, wykonywana jest tylko co n-ta regularna aktualizacja ekranu. (Może być wykorzystane do przyspieszenia rysowania złożonej grafiki.) Jeśli wywołane bez argumentów, zwraca aktualnie przechowywaną wartość n. Drugi argument ustawia wartość opóźnienia (zobacz delay()).

>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
turtle.update()

Wykonuje aktualizację ekranu TurtleScreen. Do użycia, gdy automatyczne odświeżanie ekranu (tracer) jest wyłączone.

Zobacz również metodę speed() klasy RawTurtle/Turtle.

Korzystanie ze zdarzeń ekranowych

turtle.listen(xdummy=None, ydummy=None)

Ustawia fokus na TurtleScreen, aby umożliwić odbieranie zdarzeń klawiatury. Funkcja przyjmuje dodatkowe, nieużywane argumenty, dzięki czemu funkcję :func:`listen`można przekazać do metody onclick.

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
Parametry

  • fun – funkcja bez argumentów lub None

  • key – ciąg znaków: klawisz (np. „a”) lub symbol klawisza (np. „space”)

Wiąże funkcję fun ze zdarzeniem zwolnienia klawisza. Jeśli fun ma wartość None, metoda usuwa istniejące powiązania zdarzeń. Uwaga: aby można było rejestrować zdarzenia klawiatury, TurtleScreen musi mieć fokus. (Zobacz metodę listen().)

>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onkeypress(fun, key=None)
Parametry

  • fun – funkcja bez argumentów lub None

  • key – ciąg znaków: klawisz (np. „a”) lub symbol klawisza (np. „space”)

Wiąże funkcję fun ze zdarzeniem naciśnięcia podanego klawisza albo ze zdarzeniem naciśnięcia dowolnego klawisza, jeśli klawisz nie został podany. Uwaga: aby można było rejestrować zdarzenia klawiatury, TurtleScreen musi mieć fokus. (Zobacz metodę listen().)

>>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
turtle.onclick(fun, btn=1, add=None)
turtle.onscreenclick(fun, btn=1, add=None)
Parametry

  • fun – funkcja z dwoma argumentami, która zostanie wywołana ze współrzędnymi klikniętego punktu na płótnie

  • btn – numer przycisku myszy, domyślnie 1 (lewy przycisk myszy)

  • add – True lub False – jeśli True, zostanie dodane nowe powiązanie, w przeciwnym razie zastąpi poprzednie powiązanie

Wiąże funkcję fun ze zdarzeniami kliknięcia myszą na tym ekranie. Jeśli fun ma wartość None, metoda usuwa istniejące powiązania.

Przykład dla obiektu TurtleScreen przypisanego do zmiennej screen oraz obiektu Turtle przypisanego do zmiennej turtle:

>>> screen.onclick(turtle.goto) # Subsequently clicking into the TurtleScreen will
>>>                             # make the turtle move to the clicked point.
>>> screen.onclick(None)        # remove event binding again

Informacja

Ta metoda TurtleScreen jest dostępna jako globalna funkcja wyłącznie pod nazwą onscreenclick. Globalna funkcja onclick jest inną funkcją, wywodzącą się z metody onclick klasy Turtle.

turtle.ontimer(fun, t=0)
Parametry

  • fun – funkcja bez argumentów

  • t – liczba >= 0

Ustaw czasomierz, który wywoła funkcję fun po upływie t milisekund.

>>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()   ### makes the turtle march around
>>> running = False
turtle.mainloop()
turtle.done()

Uruchamia pętlę zdarzeń, wywołując funkcję mainloop biblioteki Tkinter. Musi być ostatnią instrukcją programu korzystającego z grafiki żółwia. Nie wolno jej używać, jeśli skrypt jest uruchamiany z poziomu IDLE w trybie -n (bez podprocesów), służącym do interaktywnej pracy z grafiką żółwia.

>>> screen.mainloop()

Metody wprowadzania danych

turtle.textinput(title, prompt)
Parametry

  • title – ciąg znaków

  • prompt – ciąg znaków

Wyświetla okno dialogowe służące do wprowadzenia ciągu znaków. Parametr title to tytuł okna dialogowego, a prompt to tekst opisujący, jakie informacje należy wprowadzić. Zwraca wprowadzony ciąg znaków. Jeśli okno dialogowe zostanie zamknięte, zwraca None.

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
Parametry

  • title – ciąg znaków

  • prompt – ciąg znaków

  • default – liczba (opcjonalna)

  • minval – liczba (opcjonalna)

  • maxval – liczba (opcjonalna)

Pop up a dialog window for input of a number. title is the title of the dialog window, prompt is a text mostly describing what numerical information to input. default: default value, minval: minimum value for input, maxval: maximum value for input The number input must be in the range minval .. maxval if these are given. If not, a hint is issued and the dialog remains open for correction. Return the number input. If the dialog is canceled, return None.

>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

Ustawienia i metody specjalne

turtle.mode(mode=None)
Parametry

mode – one of the strings „standard”, „logo” or „world”

Set turtle mode („standard”, „logo” or „world”) and perform reset. If mode is not given, current mode is returned.

Mode „standard” is compatible with old turtle. Mode „logo” is compatible with most Logo turtle graphics. Mode „world” uses user-defined „world coordinates”. Attention: in this mode angles appear distorted if x/y unit-ratio doesn’t equal 1.

Mode

Initial turtle heading

positive angles

„standard”

to the right (east)

counterclockwise

„logo”

upward (north)

clockwise

 
>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
turtle.colormode(cmode=None)
Parametry

cmode – one of the values 1.0 or 255

Return the colormode or set it to 1.0 or 255. Subsequently r, g, b values of color triples have to be in the range 0..cmode.

>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
turtle.getcanvas()

Return the Canvas of this TurtleScreen. Useful for insiders who know what to do with a Tkinter Canvas.

>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
turtle.getshapes()

Return a list of names of all currently available turtle shapes.

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)

There are three different ways to call this function:

  1. name is the name of a gif-file and shape is None: Install the corresponding image shape.

    >>> screen.register_shape("turtle.gif")

    Informacja

    Image shapes do not rotate when turning the turtle, so they do not display the heading of the turtle!

  2. name is an arbitrary string and shape is a tuple of pairs of coordinates: Install the corresponding polygon shape.

    >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))

  3. name is an arbitrary string and shape is a (compound) Shape object: Install the corresponding compound shape.

Add a turtle shape to TurtleScreen’s shapelist. Only thusly registered shapes can be used by issuing the command shape(shapename).

turtle.turtles()

Return the list of turtles on the screen.

>>> for turtle in screen.turtles():
...     turtle.color("red")
turtle.window_height()

Return the height of the turtle window.

>>> screen.window_height()
480
turtle.window_width()

Return the width of the turtle window.

>>> screen.window_width()
640

Methods specific to Screen, not inherited from TurtleScreen

turtle.bye()

Shut the turtlegraphics window.

turtle.exitonclick()

Bind bye() method to mouse clicks on the Screen.

If the value „using_IDLE” in the configuration dictionary is False (default value), also enter mainloop. Remark: If IDLE with the -n switch (no subprocess) is used, this value should be set to True in turtle.cfg. In this case IDLE’s own mainloop is active also for the client script.

turtle.setup(width=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

Set the size and position of the main window. Default values of arguments are stored in the configuration dictionary and can be changed via a turtle.cfg file.

Parametry

  • width – if an integer, a size in pixels, if a float, a fraction of the screen; default is 50% of screen

  • height – if an integer, the height in pixels, if a float, a fraction of the screen; default is 75% of screen

  • startx – if positive, starting position in pixels from the left edge of the screen, if negative from the right edge, if None, center window horizontally

  • starty – if positive, starting position in pixels from the top edge of the screen, if negative from the bottom edge, if None, center window vertically

>>> screen.setup (width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers
turtle.title(titlestring)
Parametry

titlestring – a string that is shown in the titlebar of the turtle graphics window

Set title of turtle window to titlestring.

>>> screen.title("Welcome to the turtle zoo!")

Public classes

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
Parametry

canvas – a tkinter.Canvas, a ScrolledCanvas or a TurtleScreen

Create a turtle. The turtle has all methods described above as „methods of Turtle/RawTurtle”.

class turtle.Turtle

Subclass of RawTurtle, has the same interface but draws on a default Screen object created automatically when needed for the first time.

class turtle.TurtleScreen(cv)
Parametry

cv – a tkinter.Canvas

Provides screen oriented methods like bgcolor() etc. that are described above.

class turtle.Screen

Subclass of TurtleScreen, with four methods added.

class turtle.ScrolledCanvas(master)
Parametry

master – some Tkinter widget to contain the ScrolledCanvas, i.e. a Tkinter-canvas with scrollbars added

Used by class Screen, which thus automatically provides a ScrolledCanvas as playground for the turtles.

class turtle.Shape(type_, data)
Parametry

type_ – one of the strings „polygon”, „image”, „compound”

Data structure modeling shapes. The pair (type_, data) must follow this specification:

type_

data

„polygon”

a polygon-tuple, i.e. a tuple of pairs of coordinates

„image”

an image (in this form only used internally!)

„compound”

None (a compound shape has to be constructed using the addcomponent() method)
addcomponent(poly, fill, outline=None)
Parametry

  • poly – a polygon, i.e. a tuple of pairs of numbers

  • fill – a color the poly will be filled with

  • outline – a color for the poly’s outline (if given)

Przykład:

>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()

See Kształty złożone.

class turtle.Vec2D(x, y)

A two-dimensional vector class, used as a helper class for implementing turtle graphics. May be useful for turtle graphics programs too. Derived from tuple, so a vector is a tuple!

Provides (for a, b vectors, k number):

  • a + b vector addition

  • a - b vector subtraction

  • a * b inner product

  • k * a and a * k multiplication with scalar

  • abs(a) absolute value of a

  • a.rotate(angle) rotation

Help and configuration

How to use help

The public methods of the Screen and Turtle classes are documented extensively via docstrings. So these can be used as online-help via the Python help facilities:

  • When using IDLE, tooltips show the signatures and first lines of the docstrings of typed in function-/method calls.

  • Calling help() on methods or functions displays the docstrings:

    >>> help(Screen.bgcolor)
Help on method bgcolor in module turtle:

bgcolor(self, *args) unbound turtle.Screen method
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.


      >>> screen.bgcolor("orange")
      >>> screen.bgcolor()
      "orange"
      >>> screen.bgcolor(0.5,0,0.5)
      >>> screen.bgcolor()
      "#800080"

>>> help(Turtle.penup)
Help on method penup in module turtle:

penup(self) unbound turtle.Turtle method
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    >>> turtle.penup()

  • The docstrings of the functions which are derived from methods have a modified form:

    >>> help(bgcolor)
Help on function bgcolor in module turtle:

bgcolor(*args)
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.

    Example::

      >>> bgcolor("orange")
      >>> bgcolor()
      "orange"
      >>> bgcolor(0.5,0,0.5)
      >>> bgcolor()
      "#800080"

>>> help(penup)
Help on function penup in module turtle:

penup()
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    Example:
    >>> penup()

These modified docstrings are created automatically together with the function definitions that are derived from the methods at import time.

Translation of docstrings into different languages

There is a utility to create a dictionary the keys of which are the method names and the values of which are the docstrings of the public methods of the classes Screen and Turtle.

turtle.write_docstringdict(filename='turtle_docstringdict')
Parametry

filename – a string, used as filename

Create and write docstring-dictionary to a Python script with the given filename. This function has to be called explicitly (it is not used by the turtle graphics classes). The docstring dictionary will be written to the Python script filename.py. It is intended to serve as a template for translation of the docstrings into different languages.

If you (or your students) want to use turtle with online help in your native language, you have to translate the docstrings and save the resulting file as e.g. turtle_docstringdict_german.py.

If you have an appropriate entry in your turtle.cfg file this dictionary will be read in at import time and will replace the original English docstrings.

At the time of this writing there are docstring dictionaries in German and in Italian. (Requests please to glingl@aon.at.)

How to configure Screen and Turtles

The built-in default configuration mimics the appearance and behaviour of the old turtle module in order to retain best possible compatibility with it.

If you want to use a different configuration which better reflects the features of this module or which better fits to your needs, e.g. for use in a classroom, you can prepare a configuration file turtle.cfg which will be read at import time and modify the configuration according to its settings.

The built in configuration would correspond to the following turtle.cfg:

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 400
canvheight = 300
mode = standard
colormode = 1.0
delay = 10
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = Python Turtle Graphics
using_IDLE = False

Short explanation of selected entries:

  • The first four lines correspond to the arguments of the Screen.setup method.

  • Line 5 and 6 correspond to the arguments of the method Screen.screensize.

  • shape can be any of the built-in shapes, e.g: arrow, turtle, etc. For more info try help(shape).

  • If you want to use no fill color (i.e. make the turtle transparent), you have to write fillcolor = "" (but all nonempty strings must not have quotes in the cfg file).

  • If you want to reflect the turtle its state, you have to use resizemode = auto.

  • If you set e.g. language = italian the docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. in the same directory as turtle.

  • The entries exampleturtle and examplescreen define the names of these objects as they occur in the docstrings. The transformation of method-docstrings to function-docstrings will delete these names from the docstrings.

  • using_IDLE: Set this to True if you regularly work with IDLE and its -n switch („no subprocess”). This will prevent exitonclick() to enter the mainloop.

There can be a turtle.cfg file in the directory where turtle is stored and an additional one in the current working directory. The latter will override the settings of the first one.

The Lib/turtledemo directory contains a turtle.cfg file. You can study it as an example and see its effects when running the demos (preferably not from within the demo-viewer).

turtledemo — Demo scripts

The turtledemo package includes a set of demo scripts. These scripts can be run and viewed using the supplied demo viewer as follows:

python -m turtledemo

Alternatively, you can run the demo scripts individually. For example,

python -m turtledemo.bytedesign

The turtledemo package directory contains:

  • A demo viewer __main__.py which can be used to view the sourcecode of the scripts and run them at the same time.

  • Multiple scripts demonstrating different features of the turtle module. Examples can be accessed via the Examples menu. They can also be run standalone.

  • A turtle.cfg file which serves as an example of how to write and use such files.

The demo scripts are:

Nazwa

Opis

Features

bytedesign

complex classical turtle graphics pattern

tracer(), delay, update()

chaos

graphs Verhulst dynamics, shows that computer’s computations can generate results sometimes against the common sense expectations

world coordinates

clock

analog clock showing time of your computer

turtles as clock’s hands, ontimer

colormixer

experiment with r, g, b

ondrag()

forest

3 breadth-first trees

randomization

fractalcurves

Hilbert & Koch curves

recursion

lindenmayer

ethnomathematics (indian kolams)

L-System

minimal_hanoi

Towers of Hanoi

Rectangular Turtles as Hanoi discs (shape, shapesize)

nim

play the classical nim game with three heaps of sticks against the computer.

turtles as nimsticks, event driven (mouse, keyboard)

paint

super minimalistic drawing program

onclick()

peace

elementary

turtle: appearance and animation

penrose

aperiodic tiling with kites and darts

stamp()

planet_and_moon

simulation of gravitational system

compound shapes, Vec2D

rosette

a pattern from the wikipedia article on turtle graphics

clone(), undo()

round_dance

dancing turtles rotating pairwise in opposite direction

compound shapes, clone shapesize, tilt, get_shapepoly, update

sorting_animate

visual demonstration of different sorting methods

simple alignment, randomization

tree

a (graphical) breadth first tree (using generators)

clone()

two_canvases

simple design

turtles on two canvases

yinyang

another elementary example

circle()

Have fun!

Changes since Python 2.6

  • The methods Turtle.tracer, Turtle.window_width and Turtle.window_height have been eliminated. Methods with these names and functionality are now available only as methods of Screen. The functions derived from these remain available. (In fact already in Python 2.6 these methods were merely duplications of the corresponding TurtleScreen/Screen methods.)

  • The method Turtle.fill() has been eliminated. The behaviour of begin_fill() and end_fill() have changed slightly: now every filling process must be completed with an end_fill() call.

  • A method Turtle.filling has been added. It returns a boolean value: True if a filling process is under way, False otherwise. This behaviour corresponds to a fill() call without arguments in Python 2.6.

Changes since Python 3.0