turtle — Turtle graphics

Källkod: Lib/turtle.py

Introduktion

Turtle graphics är en implementation av de populära geometriska ritverktyg som introducerades i Logo, utvecklad av Wally Feurzeig, Seymour Papert och Cynthia Solomon 1967.

Kom igång

Föreställ dig en robotsköldpadda som startar vid (0, 0) i x-y-planet. Efter en import turtle, ge den kommandot turtle.forward(15), och den rör sig (på skärmen!) 15 pixlar i den riktning den är vänd, och ritar en linje medan den rör sig. Ge den kommandot turtle.right(25), och den roterar på plats 25 grader medurs.

I Python ger turtle graphics en representation av en fysisk ”sköldpadda” (en liten robot med en penna) som ritar på ett pappersark på golvet.

Det är ett effektivt och väl beprövat sätt för elever att möta programmeringskoncept och interaktion med programvara, eftersom det ger omedelbar och synlig feedback. Det ger också bekväm tillgång till grafiska utdata i allmänhet.

Turtle drawing skapades ursprungligen som ett pedagogiskt verktyg, för att användas av lärare i klassrummet. För programmerare som behöver producera grafiska utdata kan det vara ett sätt att göra det utan att behöva introducera mer komplexa eller externa bibliotek i sitt arbete.

Handledning

Nya användare bör börja här. I den här handledningen kommer vi att utforska några av grunderna i turtle-ritning.

Starta en turtle-miljö

I ett Python-skal importerar du alla objekt i modulen turtle:

från turtle import *

Om du stöter på felet No module named '_tkinter' måste du installera Tk interface package på ditt system.

Grundläggande ritning

Skicka sköldpaddan framåt 100 steg:

framåt(100)

Du bör se (troligen i ett nytt fönster på din skärm) en linje dragen av sköldpaddan, som går österut. Ändra sköldpaddans riktning så att den vrider sig 120 grader åt vänster (moturs):

vänster(120)

Låt oss fortsätta med att rita en triangel:

framåt(100)
vänster(120)
framåt(100)

Lägg märke till hur sköldpaddan, som representeras av en pil, pekar i olika riktningar när du styr den.

Experimentera med dessa kommandon, och även med backward() och right().

Kontroll av pennan

Prova att ändra färg - till exempel color('blue') - och bredd på linjen - till exempel width(3) - och rita sedan igen.

Du kan också flytta runt sköldpaddan utan att rita, genom att lyfta upp pennan: up() innan du flyttar. För att börja rita igen, använd down().

Sköldpaddans position

Skicka tillbaka din sköldpadda till startpunkten (användbart om den har försvunnit utanför skärmen):

hem()

Hemmapositionen är i mitten av sköldpaddans skärm. Om du någonsin behöver veta dem, kan du få sköldpaddans x-y-koordinater med:

pos()

Hemmet ligger vid (0, 0).

Och efter ett tag kommer det nog att hjälpa att rensa fönstret så att vi kan börja om på nytt:

rensa skärmen()

Skapa algoritmiska mönster

Med hjälp av slingor kan man bygga upp geometriska mönster:

för steg i intervall(100):
    for c in ('blå', 'röd', 'grön'):
        färg(c)
        framåt(steg)
        höger(30)

- som naturligtvis bara begränsas av fantasin!

Låt oss rita stjärnformen högst upp på den här sidan. Vi vill ha röda linjer, fyllda med gult:

färg('röd')
fyllnadsfärg('gul')

Precis som up() och down() avgör om linjer ska ritas, kan fyllning slås på och av:

börja_fyllning()

Nu ska vi skapa en slinga:

medan True:
    framåt(200)
    vänster(170)
    om abs(pos()) < 1:
        bryt

abs(pos()) < 1 är ett bra sätt att veta när sköldpaddan är tillbaka på sin hemmaposition.

Avsluta med att fylla i:

end_fill()

(Observera att fyllning faktiskt bara sker när du ger kommandot end_fill())

Hur man…

I detta avsnitt beskrivs några typiska användningsområden och tillvägagångssätt för Turtle.

Kom igång så snabbt som möjligt

Ett av glädjeämnena med sköldpaddsgrafik är den omedelbara, visuella återkopplingen som är tillgänglig från enkla kommandon - det är ett utmärkt sätt att introducera barn till programmeringsidéer, med ett minimum av overhead (inte bara barn, naturligtvis).

Modulen turtle gör detta möjligt genom att exponera alla dess grundläggande funktioner som funktioner, tillgängliga med from turtle import *. I turtle graphics tutorial beskrivs detta tillvägagångssätt.

Det är värt att notera att många av turtle-kommandona också har ännu mer kortfattade motsvarigheter, t.ex. fd() för forward(). Dessa är särskilt användbara när man arbetar med elever som inte är vana att skriva.

Du måste ha Tk-gränssnittspaketet installerat på ditt system för att turtle graphics ska fungera. Observera att detta inte alltid är helt enkelt, så kontrollera detta i förväg om du planerar att använda turtle graphics med en elev.

Börja och avsluta fyllningen automatiskt

Från och med Python 3.14 kan du använda fill() context manager istället för begin_fill() och end_fill() för att automatiskt påbörja och avsluta fill. Här är ett exempel:

med fill():
    för i i intervall(4):
        framåt(100)
        höger(90)

framåt(200)

Koden ovan är likvärdig med:

börja_fylla()
för i i intervallet(4):
    framåt(100)
    höger(90)
end_fill()

framåt(200)

Använd namnrymden för modulen turtle

Att använda from turtle import * är bekvämt - men varning för att det importerar en ganska stor samling objekt, och om du gör något annat än turtle graphics riskerar du en namnkonflikt (detta blir ett ännu större problem om du använder turtle graphics i ett skript där andra moduler kan importeras).

Lösningen är att använda import turtle - fd() blir turtle.fd(), width() blir turtle.width() och så vidare. (Om det blir tråkigt att skriva ”turtle” om och om igen, använd till exempel import turtle as t istället)

Använda turtle graphics i ett manus

Vi rekommenderar att du använder modulen turtle namespace enligt beskrivningen ovan, till exempel:

import turtle as t
from random import random

for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)
    t.right(angle)
    t.fd(steps)

Ett annat steg krävs dock också - så snart skriptet avslutas kommer Python också att stänga sköldpaddans fönster. Lägg till:

t.mainloop()

till slutet av skriptet. Skriptet väntar nu på att bli avfärdat och avslutas inte förrän det avslutas, t.ex. genom att stänga sköldpaddans grafikfönster.

Använd objektorienterad grafik för sköldpaddor

Se även

Förklaring av det objektorienterade gränssnittet

Förutom för mycket grundläggande introduktionsändamål, eller för att prova saker så snabbt som möjligt, är det vanligare och mycket mer kraftfullt att använda den objektorienterade metoden för sköldpaddsgrafik. Till exempel tillåter detta flera sköldpaddor på skärmen samtidigt.

I detta tillvägagångssätt är de olika turtle-kommandona metoder för objekt (oftast för Turtle-objekt). Du kan använda det objektorienterade tillvägagångssättet i skalet, men det skulle vara mer typiskt i ett Python-skript.

Exemplet ovan blir då:

from turtle import Sköldpadda
from random import slumpmässigt

t = Sköldpadda()
för i i intervallet(100):
    steg = int(slumpmässig() * 100)
    vinkel = int(slumpmässig() * 360)
    t.höger(vinkel)
    t.fd(steg)

t.screen.mainloop()

Notera den sista raden. t.screen är en instans av Screen som en sköldpaddsinstans finns på; den skapas automatiskt tillsammans med sköldpaddan.

Sköldpaddans skärm kan skräddarsys, till exempel:

t.screen.title("Objektorienterad sköldpaddsdemo")
t.screen.bgcolor("orange")

Sköldpaddans grafikreferens

Anteckning

I den följande dokumentationen anges argumentlistan för funktioner. Metoder har naturligtvis det ytterligare första argumentet self som utelämnas här.

Sköldpaddans metoder

Sköldpaddans rörelse
Flytta och rita
forward() | fd()
backward() | bk() | back()
right() | rt()
vänster() | lt()
goto() | setpos() | setposition()
teleport()
setx()
sety()
setheading() | seth()
hem()
cirkel()
dot()
stämpel()
clearstamp()
klara stämplar()
undo()
hastighet()
Berätta Turtle’s tillstånd
position() | pos()
towards()
xcor()
ycor()
rubrik()
avstånd()
Inställning och mätning
grader()
radianer()
Kontroll av pennan
Ritningstillstånd
pendown() | pd() | down()
penup() | pu() | up()
penstorlek() | bredd()
pen()
isdown()
Färgkontroll
färg()
pennafärg()
fillcolor()
Fyllning
fyllning()
fyllning()
begin_fill()
sluta_fyllning()
Mer ritningskontroll
återställ()
clear()
skriva()
Sköldpaddans tillstånd
Synlighet
showturtle() | st()
hideturtle() | ht()
isvisible()
Utseende
form()
resizemode()
shapesize() | turtlesize()
shearfactor()
tiltangel()
tilt()
shapetransform()
get_shapepoly()
Använda händelser
onclick()
onrelease()
ondrag()
Särskilda Turtle-metoder
poly()
begin_poly()
sluta_poly()
get_poly()
klon()
getturtle() | getpen()
getskärm()
setundobuffer()
undobufferentries()

Metoder för TurtleScreen/Screen

Kontroll av fönster
bgcolor()
bgpic()
clearscreen()
återställ skärm()
skärmstorlek()
setworldcoordinates()
Kontroll av animering
no_animation()
fördröjning()
spårare()
uppdatera()
Använda skärmhändelser
lyssna()
onkey() | onkeyrelease()
onkeypress()
onclick() | onscreenclick()
ontimer()
mainloop() | done()
Inställningar och specialmetoder
mode()
kolorläge()
getcanvas()
getshapes()
register_shape() | addshape()
sköldpaddor()
fönster_höjd()
fönsterbredd()
Inmatningsmetoder
textinmatning()
numinput()
Metoder som är specifika för Screen
hejdå()
exitonclick()
save()
setup()
titel()

Metoder för RawTurtle/Turtle och motsvarande funktioner

De flesta av exemplen i detta avsnitt hänvisar till en Turtle-instans som heter turtle.

Sköldpaddans rörelse

turtle.forward(distance)
turtle.fd(distance)
Parametrar:

distance – ett tal (heltal eller float)

Flytta sköldpaddan framåt med det angivna avståndet, i den riktning som sköldpaddan är på väg.

>>> 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)
Parametrar:

distance – ett antal

Flytta sköldpaddan bakåt med avstånd, i motsatt riktning mot den riktning som sköldpaddan är på väg mot. Ändra inte sköldpaddans kurs.

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

angle – ett tal (heltal eller float)

Vrid sköldpaddan åt höger med vinkel enheter. (Enheterna är som standard grader, men kan ställas in via funktionerna degrees() och radians()) Vinkelorienteringen beror på sköldpaddans läge, se mode().

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

angle – ett tal (heltal eller float)

Vrid sköldpaddan åt vänster med vinkel enheter. (Enheterna är som standard grader, men kan ställas in via funktionerna degrees() och radians()) Vinkelorienteringen beror på sköldpaddans läge, se 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)
Parametrar:

  • x – ett tal eller ett par/vektor av tal

  • y – ett tal eller None

Om y är None måste x vara ett koordinatpar eller en Vec2D (t.ex. som returneras av pos()).

Flytta sköldpaddan till en absolut position. Om pennan är nere, dra en linje. Ändra inte sköldpaddans orientering.

>>> 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.teleport(x, y=None, *, fill_gap=False)
Parametrar:

  • x – ett tal eller None

  • y – ett tal eller None

  • fill_gap – en boolean

Flytta sköldpaddan till en absolut position. Till skillnad från goto(x, y) kommer inte en linje att ritas. Sköldpaddans orientering ändras inte. Om polygonen fylls för närvarande kommer polygonen/polygonerna som sköldpaddan teleporteras från att fyllas efter att den lämnat platsen, och fyllningen kommer att börja igen efter teleporteringen. Detta kan inaktiveras med fill_gap=True, vilket gör att den imaginära linje som förflyttas under teleporteringen fungerar som en fyllningsbarriär som i goto(x, y).

>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.teleport(60)
>>> turtle.pos()
(60.00,0.00)
>>> turtle.teleport(y=10)
>>> turtle.pos()
(60.00,10.00)
>>> turtle.teleport(20, 30)
>>> turtle.pos()
(20.00,30.00)

Tillagd i version 3.12.

turtle.setx(x)
Parametrar:

x – ett tal (heltal eller float)

Sätt sköldpaddans första koordinat till x, lämna den andra koordinaten oförändrad.

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

y – ett tal (heltal eller float)

Ställ in sköldpaddans andra koordinat till y, lämna den första koordinaten oförändrad.

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

to_angle – ett tal (heltal eller float)

Ställ in sköldpaddans orientering till to_angle. Här är några vanliga riktningar i grader:

standardläge

logotypläge

0 - öster

0 - norr

90 - norr

90 - öster

180 - väster

180 - söderut

270 - söderut

270 - västerut

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

Flytta sköldpaddan till origo – koordinater (0,0) – och sätt dess kurs till dess startorientering (som beror på läget, se 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)
Parametrar:

  • radius – ett antal

  • extent – ett tal (eller None)

  • steps – ett heltal (eller None)

Rita en cirkel med given radius. Centrum är radius enheter till vänster om sköldpaddan; extent – en vinkel – bestämmer vilken del av cirkeln som ritas. Om extent inte anges ritas hela cirkeln. Om extent inte är en hel cirkel, är en av bågens ändpunkter den aktuella pennpositionen. Rita bågen moturs om radius är positiv, annars medurs. Slutligen ändras sköldpaddans riktning med beloppet för extent.

Eftersom cirkeln approximeras av en inskriven reguljär polygon, bestämmer steps antalet steg som ska användas. Om det inte anges beräknas det automatiskt. Kan användas för att rita reguljära polygoner.

>>> 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)
Parametrar:

  • size – ett heltal >= 1 (om det anges)

  • color – en färgsträng eller en numerisk färgtupel

Rita en cirkelformad punkt med diameter storlek, med färg. Om storlek inte anges används det högsta av pennstorlek+4 och 2*pennstorlek.

>>> 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()

Stämplar en kopia av sköldpaddsformen på duken vid den aktuella sköldpaddspositionen. Returnerar ett stamp_id för stämpeln, som kan användas för att ta bort den genom att anropa clearstamp(stamp_id).

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)
turtle.clearstamp(stampid)
Parametrar:

stampid – ett heltal, måste vara returvärdet av föregående stamp()-anrop

Ta bort stämpel med angiven stämpelid.

>>> 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)
Parametrar:

n – ett heltal (eller None)

Ta bort alla eller de första/sista n av sköldpaddans stämplar. Om n är None, radera alla stämplar, om n > 0 radera första n stämplar, annars om n < 0 radera sista n stämplar.

>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

Ångra (upprepade gånger) den/de senaste sköldpaddsaktionen/erna. Antalet tillgängliga åtgärder för ångra bestäms av storleken på ångra-bufferten.

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

speed – ett heltal i intervallet 0..10 eller en speedstring (se nedan)

Ställer in sköldpaddans hastighet till ett heltalsvärde i intervallet 0..10. Om inget argument anges returneras aktuell hastighet.

Om indata är ett tal som är större än 10 eller mindre än 0,5 sätts hastigheten till 0. Speedstrings mappas till hastighetsvärden enligt följande:

  • ”snabbast”: 0

  • ”snabb”: 10

  • ”normal”: 6

  • ”långsam”: 3

  • ”långsammast”: 1

Hastigheter från 1 till 10 ger allt snabbare animering av linjeteckning och sköldpaddsvändning.

OBS! speed = 0 innebär att ingen animation sker. framåt/bakåt får sköldpaddan att hoppa och likaså vänster/höger får sköldpaddan att svänga direkt.

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

Berätta Turtle’s tillstånd

turtle.position()
turtle.pos()

Returnerar sköldpaddans aktuella position (x,y) (som en Vec2D vektor).

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

  • x – ett tal eller ett par/vektor av tal eller en sköldpaddsinstans

  • y – ett tal om x är ett tal, annars None

Returnerar vinkeln mellan linjen från sköldpaddans position till positionen specificerad av (x,y), vektorn eller den andra sköldpaddan. Detta beror på sköldpaddans startorientering som beror på läget - ”standard”/”world” eller ”logo”.

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

Returnerar sköldpaddans x-koordinat.

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

Returnerar sköldpaddans y-koordinat.

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

Returnerar sköldpaddans aktuella kurs (värdet beror på sköldpaddans läge, se mode()).

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

  • x – ett tal eller ett par/vektor av tal eller en sköldpaddsinstans

  • y – ett tal om x är ett tal, annars None

Returnerar avståndet från sköldpaddan till (x,y), den givna vektorn eller den givna andra sköldpaddan, i sköldpaddsstegsenheter.

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

Inställningar för mätning

turtle.degrees(fullcircle=360.0)
Parametrar:

fullcircle – ett antal

Ange enheter för vinkelmätning, dvs. ange antal ”grader” för en hel cirkel. Standardvärdet är 360 grader.

>>> 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()

Ställ in vinkelmätningsenheterna till radianer. Motsvarar grader(2*math.pi).

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

Kontroll av pennan

Ritningstillstånd

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

Dra ner pennan - rita när du rör dig.

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

Dra upp pennan - ingen ritning när du rör dig.

turtle.pensize(width=None)
turtle.width(width=None)
Parametrar:

width – ett positivt tal

Ställ in linjetjockleken till width eller returnera den. Om resizemode är inställt på ”auto” och turtleshape är en polygon, ritas polygonen med samma linjetjocklek. Om inget argument anges returneras den aktuella pennstorleken.

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

  • pen – en ordbok med några eller alla av nedanstående nycklar

  • pendict – ett eller flera keyword-argument med nedanstående nycklar som nyckelord

Returnera eller ställ in pennans attribut i en ”pen-dictionary” med följande nyckel/värde-par:

  • ”visad”: Sant/Falskt

  • ”Pendown”: Sant/Falskt

  • ”pencolor”: färgsträng eller färg-tupel

  • ”fillcolor”: färgsträng eller färg-tupel

  • ”pensize”: positivt tal

  • ”speed”: tal inom intervallet 0..10

  • ”resizemode”: ”auto” eller ”user” eller ”noresize”

  • ”stretchfactor”: (positivt tal, positivt tal)

  • ”outline”: positivt tal

  • ”tilt”: antal

Denna ordbok kan användas som argument för ett efterföljande anrop till pen() för att återställa det tidigare pen-läget. Dessutom kan ett eller flera av dessa attribut anges som nyckelordsargument. Detta kan användas för att ställa in flera pennattribut i ett och samma meddelande.

>>> 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()

Returnerar True om pennan är nere, False om den är uppe.

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

Färgkontroll

turtle.pencolor(*args)

Återställ eller ställ in pennfärgen.

Fyra inmatningsformat är tillåtna:

pencolor()

Returnerar den aktuella pennfärgen som färgspecifikationssträng eller som en tupel (se exempel). Kan användas som indata till ett annat color/pencolor/fillcolor-anrop.

penfärg(färgsträng)

Ställ in pencolor på colorstring, som är en Tk-sträng för färgspecifikationer, till exempel "red", "yellow" eller "#33cc8c".

pennafärg((r, g, b))

Ställ in pencolor till RGB-färgen som representeras av tupeln r, g och b. Var och en av r, g och b måste ligga i intervallet 0..colormode, där colormode är antingen 1.0 eller 255 (se colormode()).

pennafärg(r, g, b)

Ställ in pencolor till den RGB-färg som representeras av r, g och b. Var och en av r, g och b måste ligga i intervallet 0..colormode.

Om turtleshape är en polygon ritas polygonens kontur med den nyinställda pennfärgen.

>>> 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)

Returnera eller ställ in fyllnadsfärgen.

Fyra inmatningsformat är tillåtna:

fillcolor()

Returnerar aktuell fillcolor som en färgspecifikationssträng, eventuellt i tuple-format (se exempel). Kan användas som indata till ett annat color/pencolor/fillcolor-anrop.

fillcolor(färgsträng)

Ställ in fillcolor till colorstring, som är en Tk-färgspecifikationssträng, till exempel "red", "yellow" eller "#33cc8c".

fillcolor((r, g, b))

Ställ in fillcolor på den RGB-färg som representeras av tupeln r, g och b. Var och en av r, g och b måste ligga i intervallet 0..colormode, där colormode är antingen 1,0 eller 255 (se colormode()).

fillcolor(r, g, b)

Ställ in fillcolor till den RGB-färg som representeras av r, g och b. Var och en av r, g och b måste ligga i intervallet 0..colormode.

Om turtleshape är en polygon ritas polygonens inre med den nyinställda fillcolor.

>>> 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)

Returnera eller ställ in pencolor och fillcolor.

Flera inmatningsformat är tillåtna. De använder 0 till 3 argument enligt följande:

color()

Returnerar aktuell pencolor och aktuell fillcolor som ett par färgspecifikationssträngar eller -tupler som returneras av pencolor() och fillcolor().

färg(färgsträng), färg((r,g,b))), färg(r,g,b)

Ingångar som i pencolor(), sätter båda, fillcolor och pencolor, till det angivna värdet.

färg(färgsträng1, färgsträng2), färg((r1,g1,b1), (r2,g2,b2))

Motsvarar pencolor(colorstring1) och fillcolor(colorstring2) och analogt om det andra inmatningsformatet används.

Om turtleshape är en polygon ritas polygonens kontur och insida med de nyinställda färgerna.

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

Se även följande: Skärmmetod colormode().

Fyllning

turtle.filling()

Returnerar fyllningsstatus (True om fyllning, False annars).

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

Fyller den form som ritats i blocket with turtle.fill():.

>>> turtle.color("black", "red")
>>> with turtle.fill():
...     turtle.circle(80)

Att använda fill() är likvärdigt med att lägga till begin_fill() före fill-blocket och end_fill() efter fill-blocket:

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

Tillagd i version 3.14.

turtle.begin_fill()

Anropas precis innan du ritar en form som ska fyllas.

turtle.end_fill()

Fyller den form som ritades efter det senaste anropet till begin_fill().

Huruvida överlappningsregioner för självskärande polygoner eller flera former fylls beror på operativsystemets grafik, typ av överlappning och antal överlappningar. Sköldpaddsstjärnan ovan kan till exempel antingen vara helt gul eller ha några vita områden.

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

Mer ritningskontroll

turtle.reset()

Ta bort sköldpaddans teckningar från skärmen, centrera om sköldpaddan och sätt variablerna till standardvärdena.

>>> 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()

Ta bort sköldpaddans teckningar från skärmen. Flytta inte sköldpaddan. Sköldpaddans tillstånd och position samt andra sköldpaddors teckningar påverkas inte.

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

  • arg – objekt som ska skrivas till TurtleScreen

  • move – Sant/falskt

  • align – en av strängarna ”left”, ”center” eller right”

  • font – en trippel (fontnamn, fontstorlek, fonttyp)

Skriv text - strängrepresentationen av arg - vid den aktuella sköldpaddspositionen enligt align (”left”, ”center” eller ”right”) och med det angivna teckensnittet. Om move är true flyttas pennan till det nedre högra hörnet av texten. Som standard är move False.

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

Sköldpaddans tillstånd

Synlighet

turtle.hideturtle()
turtle.ht()

Gör sköldpaddan osynlig. Det är en bra idé att göra detta medan du är mitt uppe i en komplicerad ritning, eftersom det går betydligt snabbare att rita om du döljer sköldpaddan.

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

Gör sköldpaddan synlig.

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

Returnerar True om sköldpaddan visas, False om den är dold.

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

Utseende

turtle.shape(name=None)
Parametrar:

name – en sträng som är ett giltigt shapenamn

Ställ in sköldpaddans form till formen med angivet namn eller, om namn inte anges, returnera namnet på aktuell form. Formen med namn måste finnas i TurtleScreens formordbok. Initialt finns följande polygonformer: ”arrow”, ”turtle”, ”circle”, ”square”, ”triangle”, ”classic”. För att lära dig mer om hur man hanterar former, se skärmmetoden register_shape().

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

rmode – en av strängarna ”auto”, ”user”, ”noresize”

Ställ in resizemode till ett av värdena: ”auto”, ”user”, ”noresize”. Om rmode inte anges returneras aktuellt resizemode. Olika resizemodes har följande effekter:

  • ”auto”: anpassar sköldpaddans utseende motsvarande värdet för pennstorlek.

  • ”user”: anpassar sköldpaddans utseende enligt värdena för stretchfactor och outlinewidth (outline), som ställs in av shapesize().

  • ”noresize”: ingen anpassning av sköldpaddans utseende sker.

resizemode("user") anropas av shapesize() när den används med argument.

>>> 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)
Parametrar:

  • stretch_wid – positivt tal

  • stretch_len – positivt tal

  • outline – positivt tal

Returnera eller ställ in pennans attribut x/y-stretchfactors och/eller outline. Ställ in resizemode till ”user”. Om och endast om resizemode är satt till ”user”, kommer sköldpaddan att visas utsträckt enligt dess stretchfaktorer: stretch_wid är stretchfaktorn vinkelrätt mot dess orientering, stretch_len är stretchfaktorn i riktning mot dess orientering, outline bestämmer bredden på formens kontur.

>>> 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)
Parametrar:

shear – nummer (valfritt)

Ställ in eller returnera aktuell shearfaktor. Skjuter sköldpaddsformen enligt den angivna skjuvfaktorn shear, som är tangenten till skjuvvinkeln. Ändra inte sköldpaddans kurs (rörelseriktning). Om shear inte anges: returnerar den aktuella shearfaktorn, dvs. tangenten till shearvinkeln, med vilken linjer parallella med sköldpaddans riktning klipps.

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

angle – ett antal

Rotera sköldpaddsfiguren med vinkel från dess aktuella lutningsvinkel, men ändra inte sköldpaddans riktning (rörelseriktning).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
turtle.tiltangle(angle=None)
Parametrar:

angle – ett nummer (valfritt)

Ställ in eller returnera den aktuella tilt-vinkeln. Om vinkel anges, roterar sköldpaddsformen så att den pekar i den riktning som anges av vinkel, oavsett dess aktuella tilt-vinkel. Ändra inte sköldpaddans kurs (rörelseriktning). Om angle inte anges: returnera den aktuella tilt-vinkeln, dvs. vinkeln mellan sköldpaddsformens orientering och sköldpaddans riktning (dess rörelseriktning).

>>> 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)
Parametrar:

  • t11 – ett nummer (valfritt)

  • t12 – ett nummer (valfritt)

  • t21 – ett nummer (valfritt)

  • t12 – ett nummer (valfritt)

Ställ in eller returnera den aktuella transformationsmatrisen för sköldpaddsformen.

Om inget av matriselementen anges, returneras transformationsmatrisen som en tupel med 4 element. I annat fall anges de angivna elementen och sköldpaddsformen transformeras enligt matrisen som består av första raden t11, t12 och andra raden t21, t22. Determinanten t11 * t22 - t12 * t21 får inte vara noll, annars uppstår ett fel. Modifiera stretchfactor, shearfactor och tiltangle enligt den givna matrisen.

>>> 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()

Returnerar den aktuella formpolygonen som en tupel av koordinatpar. Detta kan användas för att definiera en ny form eller komponenter i en sammansatt form.

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

Använda händelser

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

  • fun – en funktion med två argument som kommer att anropas med koordinaterna för den klickade punkten på duken

  • btn – musknappens nummer, standardvärde 1 (vänster musknapp)

  • add – True eller False – om True, läggs en ny bindning till, annars ersätter den en tidigare bindning

Bind fun till musklickhändelser på denna sköldpadda. Om fun är None tas befintliga bindningar bort. Exempel för den anonyma sköldpaddan, dvs. det procedurmässiga sättet:

>>> 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)
Parametrar:

  • fun – en funktion med två argument som kommer att anropas med koordinaterna för den klickade punkten på duken

  • btn – musknappens nummer, standardvärde 1 (vänster musknapp)

  • add – True eller False – om True, läggs en ny bindning till, annars ersätter den en tidigare bindning

Bind fun till händelser där musknappen släpps på den här sköldpaddan. Om fun är None tas befintliga bindningar bort.

>>> 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)
Parametrar:

  • fun – en funktion med två argument som kommer att anropas med koordinaterna för den klickade punkten på duken

  • btn – musknappens nummer, standardvärde 1 (vänster musknapp)

  • add – True eller False – om True, läggs en ny bindning till, annars ersätter den en tidigare bindning

Bind fun till musförflyttningshändelser på denna sköldpadda. Om fun är None tas befintliga bindningar bort.

Anmärkning: Varje sekvens av musrörelsehändelser på en sköldpadda föregås av en musklickhändelse på samma sköldpadda.

>>> turtle.ondrag(turtle.goto)

Om du sedan klickar och drar sköldpaddan flyttas den över skärmen, vilket ger handritningar (om pennan är nedtryckt).

Särskilda Turtle-metoder

turtle.poly()

Registrerar hörnpunkterna i en polygon som ritats i blocket with turtle.poly():. Det första och sista hörnet kommer att vara anslutna.

>>> with turtle.poly():
...     turtle.forward(100)
...     turtle.right(60)
...     turtle.forward(100)

Tillagd i version 3.14.

turtle.begin_poly()

Börja registrera hörnen i en polygon. Sköldpaddans nuvarande position är polygonens första toppunkt.

turtle.end_poly()

Sluta registrera hörnen i en polygon. Sköldpaddans nuvarande position är polygonens sista toppunkt. Detta kommer att anslutas till det första toppunktet.

turtle.get_poly()

Returnerar den senast registrerade polygonen.

>>> 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()

Skapa och returnera en klon av sköldpaddan med samma position, kurs och sköldpaddsegenskaper.

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

Returnerar själva Turtle-objektet. Enda rimliga användning: som en funktion för att returnera den ”anonyma sköldpaddan”:

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

Returnerar TurtleScreen-objektet som sköldpaddan ritar på. TurtleScreen-metoder kan sedan anropas för det objektet.

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

size – ett heltal eller None

Ställ in eller inaktivera undobuffer. Om size är ett heltal installeras en tom undobuffer av given storlek. size anger det maximala antalet sköldpaddsaktioner som kan ångras med metoden/funktionen undo(). Om size är None inaktiveras undobufferten.

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

Returnerar antal poster i undobufferten.

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

Sammansatta former

För att använda sammansatta sköldpaddsformer, som består av flera polygoner med olika färg, måste du använda hjälpklassen Shape explicit enligt beskrivningen nedan:

  1. Skapa ett tomt Shape-objekt av typen ”compound”.

  2. Lägg till så många komponenter som önskas till detta objekt med hjälp av metoden addcomponent().

    Till exempel:

    >>> 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. Lägg nu till Shape i skärmens shapelist och använd den:

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

Anteckning

Klassen Shape används internt av metoden register_shape() på olika sätt. Applikationsprogrammeraren måste hantera Shape-klassen endast när han använder sammansatta former som visas ovan!

Metoder för TurtleScreen/Screen och motsvarande funktioner

De flesta av exemplen i detta avsnitt hänvisar till en TurtleScreen-instans som heter screen.

Kontroll av fönster

turtle.bgcolor(*args)
Parametrar:

args – en färgsträng eller tre tal i intervallet 0..colormode eller en 3-tupel av sådana tal

Ställ in eller returnera bakgrundsfärgen för TurtleScreen.

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

picname – en sträng, namnet på en bildfil (PNG, GIF, PGM och PPM) eller "nopic", eller None

Ange bakgrundsbild eller returnera namnet på den aktuella bakgrundsbilden. Om picname är ett filnamn, anges motsvarande bild som bakgrund. Om picname är "nopic", radera bakgrundsbilden, om den finns. Om picname är None, returneras filnamnet för den aktuella bakgrundsbilden.

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

Anteckning

Denna TurtleScreen-metod är tillgänglig som en global funktion endast under namnet clearscreen. Den globala funktionen clear är en annan funktion som härrör från Turtle-metoden clear.

turtle.clearscreen()

Ta bort alla ritningar och alla sköldpaddor från TurtleScreen. Återställ den nu tomma TurtleScreen till dess ursprungliga tillstånd: vit bakgrund, ingen bakgrundsbild, inga händelsebindningar och spårning på.

turtle.reset()

Anteckning

Denna TurtleScreen-metod är tillgänglig som en global funktion endast under namnet resetscreen. Den globala funktionen reset är en annan funktion som härrör från Turtle-metoden reset.

turtle.resetscreen()

Återställ alla sköldpaddor på skärmen till deras ursprungliga tillstånd.

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
Parametrar:

  • canvwidth – positivt heltal, ny bredd på duken i pixlar

  • canvheight – positivt heltal, ny höjd på duken i pixlar

  • bg – colorstring eller color-tuple, ny bakgrundsfärg

Om inga argument anges, returneras current (canvaswidth, canvasheight). Ändra annars storleken på den duk som sköldpaddorna ritar på. Ändra inte ritfönstret. För att observera dolda delar av duken, använd rullningslisterna. Med denna metod kan man göra de delar av en ritning synliga som tidigare låg utanför duken.

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

t.ex. för att söka efter en sköldpadda som har rymt ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)
Parametrar:

  • llx – ett tal, x-koordinat för det nedre vänstra hörnet på duken

  • lly – ett tal, y-koordinat för det nedre vänstra hörnet av duken

  • urx – ett tal, x-koordinat för övre högra hörnet av duken

  • ury – ett tal, y-koordinat för övre högra hörnet av duken

Ställ in det användardefinierade koordinatsystemet och växla till läget ”world” om det behövs. Detta utför en screen.reset(). Om läget ”world” redan är aktivt ritas alla ritningar om enligt de nya koordinaterna.

OBSERVERA: I användardefinierade koordinatsystem kan vinklar se förvrängda ut.

>>> 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

Kontroll av animering

turtle.no_animation()

Avaktiverar tillfälligt animering av sköldpaddan. Koden som skrivs inuti no_animation-blocket kommer inte att animeras; när kodblocket avslutas visas teckningen.

>>> with screen.no_animation():
...     for dist in range(2, 400, 2):
...         fd(dist)
...         rt(90)

Tillagd i version 3.14.

turtle.delay(delay=None)
Parametrar:

delay – positivt heltal

Ställ in eller returnera ritningens fördröjning i millisekunder. (Detta är ungefär tidsintervallet mellan två på varandra följande canvasuppdateringar) Ju längre fördröjning, desto långsammare animation.

Valfritt argument:

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

  • n – icke-negativt heltal

  • delay – icke-negativt heltal

Slå på/av sköldpaddsanimering och ställ in fördröjning för uppdatering av ritningar. Om n anges, utförs endast varje n:te reguljära skärmuppdatering. (Kan användas för att påskynda ritningen av komplex grafik.) När den anropas utan argument returneras det aktuella lagrade värdet av n. Det andra argumentet anger fördröjningsvärdet (se delay()).

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

Utför en uppdatering av TurtleScreen. Används när spåraren är avstängd.

Se även RawTurtle/Turtle-metoden speed().

Använda skärmhändelser

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

Sätter fokus på TurtleScreen (för att samla in tangenthändelser). Dummy-argument tillhandahålls för att kunna skicka listen() till onclick-metoden.

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
Parametrar:

  • fun – en funktion utan argument eller None

  • key – en sträng: nyckel (t.ex. ”a”) eller nyckelsymbol (t.ex. ”mellanslag”)

Bind fun till key-release-händelse för nyckel. Om fun är None tas händelsebindningarna bort. Anmärkning: För att kunna registrera tangenthändelser måste TurtleScreen ha fokus. (Se metod listen().)

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

  • fun – en funktion utan argument eller None

  • key – en sträng: nyckel (t.ex. ”a”) eller nyckelsymbol (t.ex. ”mellanslag”)

Bind fun till tangenttryckningshändelsen för tangenten om tangenten är angiven, eller till valfri tangenttryckningshändelse om ingen tangent är angiven. Anmärkning: För att kunna registrera tangenthändelser måste TurtleScreen ha fokus. (Se 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)
Parametrar:

  • fun – en funktion med två argument som kommer att anropas med koordinaterna för den klickade punkten på duken

  • btn – musknappens nummer, standardvärde 1 (vänster musknapp)

  • add – True eller False – om True, läggs en ny bindning till, annars ersätter den en tidigare bindning

Bind fun till musklickhändelser på den här skärmen. Om fun är None tas befintliga bindningar bort.

Exempel för en TurtleScreen-instans med namnet screen och en Turtle-instans med namnet 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

Anteckning

Denna TurtleScreen-metod är tillgänglig som en global funktion endast under namnet onscreenclick. Den globala funktionen onclick är en annan funktion som härrör från Turtle-metoden onclick.

turtle.ontimer(fun, t=0)
Parametrar:

  • fun – en funktion utan argument

  • t – ett tal >= 0

Installera en timer som anropar fun efter t millisekunder.

>>> 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()

Startar händelseslinga - anropar Tkinters mainloop-funktion. Måste vara den sista satsen i ett turtle graphics-program. Får inte användas om ett skript körs från IDLE i -n-läge (ingen subprocess) - för interaktiv användning av turtle graphics.

>>> screen.mainloop()

Inmatningsmetoder

turtle.textinput(title, prompt)
Parametrar:

  • title – sträng

  • prompt – sträng

Öppnar ett dialogfönster för inmatning av en sträng. Parameter title är titeln på dialogfönstret, prompt är en text som mestadels beskriver vilken information som ska matas in. Returnerar den inmatade strängen. Om dialogrutan avbryts returneras None.

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

  • title – sträng

  • prompt – sträng

  • default – nummer (valfritt)

  • minval – nummer (valfritt)

  • maxval – nummer (valfritt)

Popa upp ett dialogfönster för inmatning av ett tal. title är titeln på dialogfönstret, prompt är en text som mestadels beskriver vilken numerisk information som ska matas in. default: standardvärde, minval: lägsta värde för inmatning, maxval: högsta värde för inmatning. Det inmatade talet måste ligga inom intervallet minval .. maxval om dessa anges. Om så inte är fallet ges en hint och dialogen förblir öppen för korrigering. Returnera det inmatade talet. Om dialogen avbryts, returneras None.

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

Inställningar och specialmetoder

turtle.mode(mode=None)
Parametrar:

mode – en av strängarna ”standard”, ”logo” eller ”world”

Ställ in turtle mode (”standard”, ”logo” eller ”world”) och utför reset. Om mode inte anges returneras aktuellt läge.

Läget ”standard” är kompatibelt med gamla turtle. Läget ”logo” är kompatibelt med de flesta Logo sköldpaddsgrafiker. Läge ”world” använder användardefinierade ”världskoordinater”. Attention: i detta läge ser vinklar förvrängda ut om enhetsförhållandet x/y inte är lika med 1.

Läge

Sköldpaddans initiala kurs

positiva vinklar

”standard”

till höger (öster)

moturs

”logotyp”

uppåt (norr)

medurs

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

cmode – ett av värdena 1.0 eller 255

Returnerar färgmodet eller sätter det till 1.0 eller 255. Därefter måste r-, g-, b-värdena för färgtripplar ligga i intervallet 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()

Returnerar Canvas för denna TurtleScreen. Användbart för insiders som vet vad de ska göra med en Tkinter Canvas.

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

Returnerar en lista med namn på alla tillgängliga sköldpaddsformer.

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

Det finns fyra olika sätt att anropa denna funktion:

  1. name är namnet på en bildfil (PNG, GIF, PGM och PPM) och shape är None: Installera motsvarande bildform.

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

    Anteckning

    Bildformerna roterar inte när sköldpaddan vrids, så de visar inte sköldpaddans riktning!

  2. name är en godtycklig sträng och shape är namnet på en bildfil (PNG, GIF, PGM och PPM): Installera motsvarande bildform.

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

    Anteckning

    Bildformerna roterar inte när sköldpaddan vrids, så de visar inte sköldpaddans riktning!

  3. name är en godtycklig sträng och shape är en tupel av koordinatpar: Installera motsvarande polygonform.

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

  4. name är en godtycklig sträng och shape är ett (sammansatt) Shape-objekt: Installera motsvarande sammansatta form.

Lägg till en sköldpaddsform i TurtleScreens formlista. Endast sålunda registrerade former kan användas genom att ge kommandot form(formnamn).

Ändrad i version 3.14: Stöd för PNG-, PGM- och PPM-bildformat har lagts till. Både ett formnamn och ett bildfilnamn kan anges.

turtle.turtles()

Returnera listan över sköldpaddor på skärmen.

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

Returnera höjden på sköldpaddans fönster.

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

Returnera bredden på sköldpaddans fönster.

>>> screen.window_width()
640

Metoder som är specifika för Screen och som inte ärvs från TurtleScreen

turtle.bye()

Stäng fönstret turtlegraphics.

turtle.exitonclick()

Binda metoden bye() till musklick på skärmen.

Om värdet ”using_IDLE” i konfigurationsordlistan är False (standardvärde), ska även mainloop startas. Anmärkning: Om IDLE med -n switch (ingen subprocess) används, bör detta värde sättas till True i turtle.cfg. I detta fall är IDLE:s egen huvudslinga aktiv även för klientskriptet.

turtle.save(filename, overwrite=False)

Spara den aktuella sköldpaddsritningen (och sköldpaddorna) som en PostScript-fil.

Parametrar:

  • filename – sökvägen till den sparade PostScript-filen

  • overwrite – om False och det redan finns en fil med det angivna filnamnet, kommer funktionen att ge upphov till ett FileExistsError. Om det är True, kommer filen att skrivas över.

>>> screen.save("my_drawing.ps")
>>> screen.save("my_drawing.ps", overwrite=True)

Tillagd i version 3.14.

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

Ställer in storlek och position för huvudfönstret. Standardvärden för argument lagras i konfigurationsordlistan och kan ändras via en turtle.cfg-fil.

Parametrar:

  • width – om ett heltal, en storlek i pixlar, om en float, en bråkdel av skärmen; standard är 50% of screen

  • height – om ett heltal, höjden i pixlar, om en float, en bråkdel av skärmen; standard är 75% of screen

  • startx – om positiv, startposition i pixlar från skärmens vänstra kant, om negativ från höger kant, om None, centrera fönstret horisontellt

  • starty – om positiv, startposition i pixlar från skärmens övre kant, om negativ från den nedre kanten, om None, centrera fönstret vertikalt

>>> 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)
Parametrar:

titlestring – en sträng som visas i titelfältet i sköldpaddans grafikfönster

Ställ in titeln på sköldpaddsfönstret till titlestring.

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

Offentliga klasser

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
Parametrar:

canvas – en tkinter.Canvas, en ScrolledCanvas eller en TurtleScreen

Skapa en sköldpadda. Sköldpaddan har alla metoder som beskrivs ovan som ”metoder för Turtle/RawTurtle”.

class turtle.Turtle

Underklass till RawTurtle, har samma gränssnitt men ritar på ett standardobjekt Screen som skapas automatiskt när det behövs för första gången.

class turtle.TurtleScreen(cv)
Parametrar:

cv – en tkinter.Canvas

Tillhandahåller skärmorienterade metoder som bgcolor() etc. som beskrivs ovan.

class turtle.Screen

Underklass av TurtleScreen, med fyra metoder tillagda.

class turtle.ScrolledCanvas(master)
Parametrar:

master – en Tkinter-widget som innehåller ScrolledCanvas, dvs. en Tkinter-canvas med tillägg av rullningslister

Används av klassen Screen, som därmed automatiskt tillhandahåller en ScrolledCanvas som lekplats för sköldpaddorna.

class turtle.Shape(type_, data)
Parametrar:

type_ – en av strängarna ”polygon”, ”image”, ”compound”

Former för modellering av datastrukturer. Paret (typ_, data) måste följa denna specifikation:

typ_

data

”polygon”

en polygon-tupel, dvs. en tupel av koordinatpar

”bild”

en bild (i denna form används den endast internt!)

”sammansatt”

None (en sammansatt form måste konstrueras med hjälp av metoden addcomponent())
addcomponent(poly, fill, outline=None)
Parametrar:

  • poly – en polygon, d.v.s. en tupel av talpar

  • fill – en färg som poly kommer att fyllas med

  • outline – en färg för polygonens kontur (om den anges)

Exempel:

>>> 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()

Se Sammansatta former.

class turtle.Vec2D(x, y)

En tvådimensionell vektorklass som används som en hjälpklass för att implementera sköldpaddsgrafik. Kan vara användbar för sköldpaddsgrafikprogram också. Härledd från tuple, så en vektor är en tuple!

Ger (för a, b vektorer, k nummer):

  • a + b vektor addition

  • a - b vektorns subtraktion

  • a * b inre produkt

  • multiplikation av k * a och a * k med skalär

  • abs(a) absolut värde av a

  • a.rotera(vinkel) rotation

Förklaring

Ett turtle-objekt ritar på ett screen-objekt och det finns ett antal nyckelklasser i det objektorienterade gränssnittet turtle som kan användas för att skapa dem och relatera dem till varandra.

En Turtle-instans skapar automatiskt en Screen-instans om en sådan inte redan finns.

Turtle är en underklass av RawTurtle, som inte automatiskt skapar en rityta - en canvas måste tillhandahållas eller skapas för den. Canvas kan vara en tkinter.Canvas, ScrolledCanvas eller TurtleScreen.

TurtleScreen är den grundläggande ritytan för en sköldpadda. Screen är en underklass av TurtleScreen, och innehåller vissa ytterligare metoder för att hantera dess utseende (inklusive storlek och titel) och beteende. TurtleScreen’s konstruktor behöver en tkinter.Canvas eller en ScrolledCanvas som argument.

Det funktionella gränssnittet för sköldpaddsgrafik använder de olika metoderna i Turtle och TurtleScreen/Screen. Bakom kulisserna skapas automatiskt ett screen-objekt när en funktion som härrör från en Screen-metod anropas. På samma sätt skapas ett turtle-objekt automatiskt när någon av de funktioner som härrör från en turtle-metod anropas.

För att använda flera sköldpaddor på en skärm måste det objektorienterade gränssnittet användas.

Hjälp och konfiguration

Hur man använder hjälp

De publika metoderna i klasserna Screen och Turtle är utförligt dokumenterade via docstrings. Så dessa kan användas som online-hjälp via Pythons hjälpfunktioner:

  • När IDLE används visar verktygstipsen signaturerna och de första raderna i dokumentsträngarna för de funktions-/metodanrop som skrivits in.

  • Om du anropar help() på metoder eller funktioner visas dokumentationen:

    >>> 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()

  • Dokumentationen av de funktioner som härrör från metoder har en modifierad 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()

Dessa modifierade docstrings skapas automatiskt tillsammans med de funktionsdefinitioner som härleds från metoderna vid importtillfället.

Översättning av docstrings till olika språk

Det finns ett verktyg för att skapa en ordbok vars nycklar är metodnamnen och vars värden är dokumentsträngarna för de offentliga metoderna i klasserna Screen och Turtle.

turtle.write_docstringdict(filename='turtle_docstringdict')
Parametrar:

filename – en sträng, används som filnamn

Skapa och skriv docstring-dictionary till ett Python-skript med det angivna filnamnet. Denna funktion måste anropas explicit (den används inte av turtle graphics-klasserna). Docstring-ordboken kommer att skrivas till Python-skriptet filename.py. Den är avsedd att fungera som en mall för översättning av docstrings till olika språk.

Om du (eller dina studenter) vill använda turtle med onlinehjälp på ditt modersmål, måste du översätta dokumentationen och spara den resulterande filen som t.ex. turtle_docstringdict_german.py.

Om du har en lämplig post i din turtle.cfg-fil kommer denna ordbok att läsas in vid importtillfället och ersätta de engelska originaldokumenten.

När detta skrivs finns det docstring-ordböcker på tyska och italienska. (Förfrågningar till glingl@aon.at.)

Så här konfigurerar du Screen and Turtles

Den inbyggda standardkonfigurationen efterliknar utseendet och beteendet hos den gamla turtle-modulen för att bibehålla bästa möjliga kompatibilitet med den.

Om du vill använda en annan konfiguration som bättre återspeglar funktionerna i denna modul eller som bättre passar dina behov, t.ex. för användning i ett klassrum, kan du förbereda en konfigurationsfil turtle.cfg som kommer att läsas vid importtillfället och ändra konfigurationen enligt dess inställningar.

Den inbyggda konfigurationen skulle motsvara följande turtle.cfg:

bredd = 0,5
höjd = 0,75
vänster höger = Ingen
topbottom = Ingen
kanvbredd = 400
höjd på bild = 300
läge = standard
färgläge = 1.0
fördröjning = 10
undobuffersize = 1000
form = klassisk
pennfärg = svart
fyllnadsfärg = svart
storleksändringsläge = noresize
synlig = sann
språk = engelska
exampleturtle = sköldpadda
exempelskärm = skärm
title = Python sköldpaddsgrafik
using_IDLE = Falsk

Kort förklaring av utvalda poster:

  • De fyra första raderna motsvarar argumenten i metoden Screen.setup.

  • Rad 5 och 6 motsvarar argumenten i metoden Screen.screensize.

  • shape kan vara vilken som helst av de inbyggda formerna, t.ex. pil, sköldpadda osv. För mer information, se help(shape).

  • Om du inte vill använda någon fyllnadsfärg (t.ex. göra sköldpaddan genomskinlig) måste du skriva fillcolor = "" (men alla icke-tomma strängar får inte ha citattecken i cfg-filen).

  • Om du vill återspegla sköldpaddans tillstånd måste du använda resizemode = auto.

  • Om du t.ex. anger language = italian kommer docstringdict turtle_docstringdict_italian.py att laddas vid importtillfället (om den finns på importsökvägen, t.ex. i samma katalog som turtle).

  • Posterna exampleturtle och examplescreen definierar namnen på dessa objekt så som de förekommer i dokumentsträngarna. När metoddokumentationer omvandlas till funktionsdokumentationer kommer dessa namn att tas bort från dokumentationerna.

  • använder_IDLE: Sätt detta till True om du regelbundet arbetar med IDLE och dess -n switch (”no subprocess”). Detta kommer att förhindra exitonclick() att gå in i huvudslingan.

Det kan finnas en turtle.cfg-fil i den katalog där turtle lagras och ytterligare en i den aktuella arbetskatalogen. Den senare kommer att åsidosätta inställningarna i den första.

I katalogen Lib/turtledemo finns en fil turtle.cfg. Du kan studera den som ett exempel och se dess effekter när du kör demona (helst inte från demovisaren).

turtledemo — Demoskript

Paketet turtledemo innehåller en uppsättning demoskript. Dessa skript kan köras och visas med hjälp av den medföljande demovisaren enligt följande:

python -m turtledemo

Alternativt kan du köra demoskripten var för sig. Till exempel

python -m turtledemo.bytedesign

Paketkatalogen turtledemo innehåller:

  • En demovisare __main__.py som kan användas för att visa källkoden för skripten och köra dem samtidigt.

  • Flera skript som demonstrerar olika funktioner i modulen turtle. Du kan komma åt exemplen via menyn Examples. De kan också köras fristående.

  • En turtle.cfg-fil som fungerar som ett exempel på hur man skriver och använder sådana filer.

Demoskriptet är:

Namn

Beskrivning

Funktioner

bytedesign

komplext klassiskt sköldpaddsgrafiskt mönster

tracer(), fördröjning, update()

kaos

graf Verhulst dynamik, visar att datorns beräkningar kan generera resultat som ibland strider mot sunt förnufts förväntningar

världskoordinater

klocka

analog klocka som visar tiden för din dator

sköldpaddor som klockvisare, ontimer

färgblandare

experimentera med r, g, b

ondrag()

skog

3 Bredd-först-träd

randomisering

fractalcurves

Hilbert- och Koch-kurvor

rekursion

lindenmayer

etnomatematik (indiska kolamer)

L-system

minimal_hanoi

Tornen i Hanoi

Rektangulära sköldpaddor som Hanoi-skivor (form, shapesize)

nim

spela det klassiska nim-spelet med tre högar av pinnar mot datorn.

sköldpaddor som nimsticks, händelsestyrd (mus, tangentbord)

färg

super minimalistiskt ritprogram

onclick()

fred

elementär

sköldpadda: utseende och animation

penros

aperiodiska plattor med drakar och pilar

stämpel()

planet_och_måne

simulering av gravitationssystem

sammansatta former, Vec2D

rosett

ett mönster från wikipediaartikeln om sköldpaddsgrafik

clone(), undo()

runddans

dansande sköldpaddor som roterar parvis i motsatt riktning

sammansatta former, klona former storlek, lutning, get_shapepoly, uppdatering

sortering_animerad

visuell demonstration av olika sorteringsmetoder

enkel justering, randomisering

träd

ett (grafiskt) träd med första bredden (med hjälp av generatorer)

klon()

två_kanvaser

enkel design

sköldpaddor på två dukar

yinyang

ett annat elementärt exempel

cirkel()

Ha kul!

Ändringar sedan Python 2.6

  • Metoderna Turtle.tracer, Turtle.window_width och Turtle.window_height har tagits bort. Metoder med dessa namn och funktioner är nu endast tillgängliga som metoder i Screen. De funktioner som härrör från dessa är fortfarande tillgängliga. (Faktum är att redan i Python 2.6 var dessa metoder bara dupliceringar av motsvarande TurtleScreen/Screen-metoder)

  • Metoden Turtle.fill() har tagits bort. Beteendet för begin_fill() och end_fill() har ändrats något: nu måste varje fyllningsprocess avslutas med ett end_fill()-anrop.

  • En metod Turtle.filling har lagts till. Den returnerar ett booleanskt värde: True om en fyllningsprocess pågår, False annars. Detta beteende motsvarar ett fill()-anrop utan argument i Python 2.6.

Ändringar sedan Python 3.0

  • Metoderna Turtle shearfactor(), shapetransform() och get_shapepoly() har lagts till. Därmed finns nu hela utbudet av vanliga linjära transformationer tillgängliga för att transformera sköldpaddsformer. tiltangle() har fått utökad funktionalitet: den kan nu användas för att få eller ställa in lutningsvinkeln.

  • Metoden Screen onkeypress() har lagts till som ett komplement till onkey(). Eftersom den senare binder åtgärder till nyckelutlösningshändelsen, har ett alias: onkeyrelease() också lagts till för den.

  • Metoden Screen.mainloop har lagts till, så det finns inte längre något behov av att använda den fristående funktionen mainloop() när man arbetar med objekten Screen och Turtle.

  • Två inmatningsmetoder har lagts till: Screen.textinput och Screen.numinput. Dessa öppnar inmatningsdialoger och returnerar strängar respektive siffror.