turtle — Черепашья графика

Источник: Lib/turtle.py

---

Введение

Черепашья графика - это реализация the popular geometric drawing tools introduced in Logo, разработанная Уолли Фурзейгом, Сеймуром Пейпертом и Синтией Соломон в 1967 году.

Начать

Представьте себе роботизированную черепаху, стартующую в точке (0, 0) в плоскости x-y. После выполнения команды import turtle дайте ей команду turtle.forward(15), и она перемещается (на экране!) на 15 пикселей в направлении, в котором она находится, рисуя линию по мере движения. Дайте ему команду turtle.right(25), и он повернется на месте на 25 градусов по часовой стрелке.

Turtle star

Черепаха может рисовать замысловатые фигуры с помощью программ, повторяющих простые движения.

В Python черепашья графика обеспечивает представление физической «черепахи» (маленького робота с ручкой), которая рисует на листе бумаги на полу.

Это эффективный и хорошо зарекомендовавший себя способ ознакомления учащихся с концепциями программирования и взаимодействия с программным обеспечением, поскольку он обеспечивает мгновенную и наглядную обратную связь. Кроме того, он обеспечивает удобный доступ к графическому выводу в целом.

Черепашье рисование изначально создавалось как образовательный инструмент, для использования преподавателями в классе. Для программистов, которым нужно выводить графику, это может быть способом сделать это без необходимости внедрять в работу более сложные или внешние библиотеки.

Учебное пособие

Новым пользователям следует начать с этой страницы. В этом уроке мы изучим некоторые основы рисования черепашек.

Запуск черепашьей среды

В оболочке Python импортируйте все объекты модуля turtle:

from turtle import *

Если вы столкнулись с ошибкой No module named '_tkinter', вам придется установить Tk interface package на свою систему.

Базовый рисунок

Отправьте черепаху вперед на 100 шагов:

forward(100)

Вы должны увидеть (скорее всего, в новом окне на экране) линию, проведенную черепахой, которая направлена на восток. Измените направление движения черепахи так, чтобы она повернулась на 120 градусов влево (против часовой стрелки):

left(120)

Продолжим рисовать треугольник:

forward(100)
left(120)
forward(100)

Обратите внимание, как черепаха, изображенная стрелкой, направляется в разные стороны, когда вы управляете ею.

Поэкспериментируйте с этими командами, а также с командами backward() и right().

Управление ручкой

Попробуйте изменить цвет - например, color('blue') - и ширину линии - например, width(3). - а затем снова нарисовать.

Вы также можете перемещать черепаху без рисования, подняв перо: up() перед перемещением. Чтобы снова начать рисовать, используйте down().

Положение черепахи

Верните черепаху в исходную точку (полезно, если она исчезла за пределами экрана):

home()

Домашняя позиция находится в центре экрана черепашки. Если вам когда-нибудь понадобится узнать их, получите координаты черепашки x-y с помощью:

pos()

Дом находится по адресу (0, 0).

И через некоторое время, возможно, поможет очистить окно, чтобы мы могли начать все заново:

clearscreen()

Создание алгоритмических моделей

Используя петли, можно выстраивать геометрические узоры:

for steps in range(100):
    for c in ('blue', 'red', 'green'):
        color(c)
        forward(steps)
        right(30)

- которые, конечно, ограничены только воображением!

Давайте нарисуем форму звезды в верхней части этой страницы. Нам нужны красные линии, заполненные желтым:

color('red')
fillcolor('yellow')

Так же как up() и down() определяют, будут ли нарисованы линии, заливку можно включать и выключать:

begin_fill()

Далее мы создадим цикл:

while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break

abs(pos()) < 1 - хороший способ узнать, когда черепаха вернулась в исходное положение.

Наконец, завершите заполнение:

end_fill()

(Обратите внимание, что заполнение происходит только тогда, когда вы даете команду end_fill()).

Как…

В этом разделе рассматриваются некоторые типичные случаи использования черепах и подходы к ним.

Приступайте к работе как можно быстрее

Одна из радостей черепашьей графики - мгновенная визуальная обратная связь, которую можно получить от простых команд. Это отличный способ познакомить детей с идеями программирования с минимальными накладными расходами (не только детей, конечно).

Модуль turtle делает это возможным, раскрывая всю свою базовую функциональность как функции, доступные с помощью from turtle import *. В разделе turtle graphics tutorial рассматривается этот подход.

Стоит отметить, что многие команды «черепахи» имеют еще более краткие эквиваленты, например fd() для forward(). Они особенно полезны при работе с учениками, для которых набор текста не является навыком.

Чтобы черепашья графика работала, в вашей системе должен быть установлен Tk interface package. Имейте в виду, что это не всегда просто, поэтому проверьте это заранее, если вы планируете использовать черепашью графику с учеником.

Используйте пространство имен модуля turtle.

Использование from turtle import * удобно - но учтите, что при этом импортируется довольно большая коллекция объектов, и если вы делаете что-то кроме черепашьей графики, то рискуете столкнуться с конфликтом имен (это становится еще большей проблемой, если вы используете черепашью графику в сценарии, где могут быть импортированы другие модули).

Решение состоит в том, чтобы использовать import turtle. - fd() становится turtle.fd(), width() становится turtle.width() и так далее. (Если набирать слово «черепаха» снова и снова становится утомительно, используйте вместо него, например, import turtle as t).

Использование черепашьей графики в сценарии

Рекомендуется использовать пространство имен модуля turtle, как описано выше, например:

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)

Однако потребуется еще один шаг - как только скрипт завершится, Python также закроет окно черепахи. Добавить:

t.mainloop()

в конец сценария. Теперь скрипт будет ожидать завершения и не выйдет, пока его не завершат, например, закрыв графическое окно черепашки.

Используйте объектно-ориентированную черепашью графику

См.также

Explanation of the object-oriented interface

За исключением самых простых вводных целей или быстрого опробования, более привычным и гораздо более мощным является использование объектно-ориентированного подхода к черепашьей графике. Например, это позволяет одновременно выводить на экран несколько черепах.

При таком подходе различные команды черепахи являются методами объектов (в основном объектов Turtle). Вы можете использовать объектно-ориентированный подход в оболочке, но это было бы более типично для сценариев Python.

Тогда пример выше становится:

from turtle import Turtle
from random import random

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

t.screen.mainloop()

Обратите внимание на последнюю строку. t.screen - это экземпляр Screen, на котором существует экземпляр черепахи; он создается автоматически вместе с черепахой.

Экран черепахи можно настроить, например:

t.screen.title('Object-oriented turtle demo')
t.screen.bgcolor("orange")

Справочник по черепашьей графике

Примечание

В следующей документации приведен список аргументов для функций. Методы, конечно, имеют дополнительный первый аргумент self, который здесь опущен.

Черепашьи методы

Движение черепахи

Двигайтесь и рисуйте

forward() | fd()

backward() | bk() | back()

right() | rt()

left() | lt()

goto() | setpos() | setposition()

teleport()

setx()

sety()

setheading() | seth()

home()

circle()

dot()

stamp()

clearstamp()

clearstamps()

undo()

speed()

Расскажите о состоянии Черепахи

position() | pos()

towards()

xcor()

ycor()

heading()

distance()

Установка и измерение

degrees()

radians()

Управление ручкой

Состояние рисунка

pendown() | pd() | down()

penup() | pu() | up()

pensize() | width()

pen()

isdown()

Управление цветом

color()

pencolor()

fillcolor()

Наполнение

filling()

begin_fill()

end_fill()

Больше контроля над рисунком

reset()

clear()

write()

Состояние черепахи

Видимость

showturtle() | st()

hideturtle() | ht()

isvisible()

Внешний вид

shape()

resizemode()

shapesize() | turtlesize()

shearfactor()

tiltangle()

tilt()

shapetransform()

get_shapepoly()

Использование событий

onclick()

onrelease()

ondrag()

Специальные методы черепахи

begin_poly()

end_poly()

get_poly()

clone()

getturtle() | getpen()

getscreen()

setundobuffer()

undobufferentries()

Методы TurtleScreen/Screen

Управление окнами

bgcolor()

bgpic()

clearscreen()

resetscreen()

screensize()

setworldcoordinates()

Управление анимацией

delay()

tracer()

update()

Использование событий экрана

listen()

onkey() | onkeyrelease()

onkeypress()

onclick() | onscreenclick()

ontimer()

mainloop() | done()

Настройки и специальные методы

mode()

colormode()

getcanvas()

getshapes()

register_shape() | addshape()

turtles()

window_height()

window_width()

Методы ввода

textinput()

numinput()

Методы, характерные для Screen

bye()

exitonclick()

setup()

title()

Методы RawTurtle/Turtle и соответствующие функции

Большинство примеров в этом разделе относятся к экземпляру Черепахи с именем turtle.

Движение черепахи

turtle.forward(distance)

turtle.fd(distance)

Параметры:

distance – число (целое или плавающее)

Переместите черепашку вперед на указанное расстояние, в том направлении, куда она направляется.

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

Параметры:

distance – число

Переместите черепаху назад на расстояние, противоположное направлению движения черепахи. Не меняйте направление движения черепахи.

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)

turtle.right(angle)

turtle.rt(angle)

Параметры:

angle – число (целое или плавающее)

Повернуть черепашку вправо на угол единиц. (По умолчанию единицы измерения - градусы, но их можно установить с помощью функций degrees() и radians()). Ориентация угла зависит от режима черепашки, см. mode().

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0

turtle.left(angle)

turtle.lt(angle)

Параметры:

angle – число (целое или плавающее)

Повернуть черепашку влево на угол единиц. (По умолчанию единицы измерения - градусы, но их можно установить с помощью функций degrees() и radians()). Ориентация угла зависит от режима черепашки, см. 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)

Параметры:

• x – число или пара/вектор чисел

• y – число или None

Если y - это None, то x должна быть парой координат или Vec2D (например, как возвращается pos()).

Переместите черепашку в абсолютное положение. Если перо опущено, нарисуйте линию. Не меняйте ориентацию черепахи.

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

Параметры:

• x – число или None

• y – число или None

• fill_gap – логическое число

Переместите черепашку в абсолютную позицию. В отличие от goto(x, y), линия не будет нарисована. Ориентация черепашки не меняется. Если в данный момент происходит заполнение, то полигон(ы), из которого телепортировалась черепаха, будет заполнен после выхода, а после телепортации заполнение начнется снова. Это можно отключить с помощью fill_gap=True, что заставит воображаемую линию, пройденную во время телепортации, действовать как барьер для заливки, как в 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)

Added in version 3.12.

turtle.setx(x)

Параметры:

x – число (целое или плавающее)

Установите первую координату черепашки в x, вторую оставьте без изменений.

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

turtle.sety(y)

Параметры:

y – число (целое или плавающее)

Установите вторую координату черепашки в y, первую оставьте без изменений.

>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)

turtle.setheading(to_angle)

turtle.seth(to_angle)

Параметры:

to_angle – число (целое или плавающее)

Установите ориентацию черепашки на to_angle. Вот некоторые распространенные направления в градусах:

стандартный режим	режим логотипа
0 - восток	0 - север
90 - север	90 - восток
180 - запад	180 - юг
270 - юг	270 - запад

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

turtle.home()

Переместите черепашку в начало координат - координаты (0,0) - и установите ее курс на начальную ориентацию (которая зависит от режима, см. 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)

Параметры:

• radius – число

• extent – число (или None)

• steps – целое число (или None)

Рисует окружность с заданным радиусом. Центр находится на радиус единиц левее черепахи; extent - угол - определяет, какая часть окружности будет нарисована. Если extent не задан, рисуется вся окружность. Если extent не является полной окружностью, то одной из конечных точек дуги будет текущая позиция пера. Если радиус положителен, рисуйте дугу против часовой стрелки, в противном случае - по часовой стрелке. Наконец, направление черепашки изменяется на величину extent.

Поскольку окружность аппроксимируется вписанным правильным многоугольником, steps определяет количество шагов, которые необходимо использовать. Если оно не задано, оно будет вычислено автоматически. Может использоваться для рисования правильных многоугольников.

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

Параметры:

• size – целое число >= 1 (если задано)

• color – строка цвета или числовой кортеж цвета

Нарисуйте круглую точку диаметром size, используя color. Если size не указан, используется максимальное значение из pensize+4 и 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()

Штампует копию фигуры черепахи на холст в текущей позиции черепахи. Возвращает идентификатор штампа, который можно использовать для его удаления, вызвав clearstamp(stamp_id).

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)

turtle.clearstamp(stampid)

Параметры:

stampid – целое число, должно быть возвращаемым значением предыдущего вызова stamp().

Удаление штампа с заданным 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)

Параметры:

n – целое число (или None)

Удаляет все или первые/последние n штампов черепахи. Если n равно None, удаляются все штампы, если n > 0, удаляются первые n штампов, если n < 0, удаляются последние n штампов.

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

turtle.undo()

Отмена (повторная) последнего действия (действий) черепашки. Количество доступных действий отмены определяется размером буфера отмены.

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

turtle.speed(speed=None)

Параметры:

speed – целое число в диапазоне 0…10 или строка скорости (см. ниже)

Установите скорость черепахи в целое значение в диапазоне 0…10. Если аргумент не указан, возвращается текущая скорость.

Если входное число больше 10 или меньше 0,5, скорость устанавливается в 0. Строки скоростей сопоставляются со значениями скорости следующим образом:

• «Самый быстрый»: 0

• «быстро»: 10

• «Нормальный»: 6

• «медленно»: 3

• «Самый медленный»: 1

Скорости от 1 до 10 обеспечивают все более быструю анимацию рисования линий и поворота черепашки.

Внимание: speed = 0 означает, что никакой анимации не происходит. движение вперед/назад заставляет черепаху прыгать, а движение влево/вправо - мгновенно поворачивать.

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

Расскажите о состоянии Черепахи

turtle.position()

turtle.pos()

Возвращает текущее местоположение черепахи (x,y) (в виде вектора Vec2D).

>>> turtle.pos()
(440.00,-0.00)

turtle.towards(x, y=None)

Параметры:

• x – число или пара/вектор чисел или экземпляр черепахи

• y – число, если x - число, иначе None

Возвращает угол между линией от позиции черепахи до позиции, заданной (x,y), вектором или другой черепахой. Это зависит от начальной ориентации черепашки, которая зависит от режима - «стандартный»/«мир» или «логотип».

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

turtle.xcor()

Возвращает координату x черепахи.

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

turtle.ycor()

Возвращает координату y черепахи.

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

turtle.heading()

Возвращает текущий курс черепашки (значение зависит от режима черепашки, см. mode()).

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0

turtle.distance(x, y=None)

Параметры:

• x – число или пара/вектор чисел или экземпляр черепахи

• y – число, если x - число, иначе None

Возвращает расстояние от черепахи до (x,y), заданного вектора или заданной другой черепахи в единицах шага черепахи.

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

Настройки для измерения

turtle.degrees(fullcircle=360.0)

Параметры:

fullcircle – число

Установите единицы измерения угла, т.е. задайте количество «градусов» для полного круга. Значение по умолчанию - 360 градусов.

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

Установите единицы измерения угла в радианы. Эквивалентно degrees(2*math.pi).

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

Управление ручкой

Состояние рисунка

turtle.pendown()

turtle.pd()

turtle.down()

Потяните перо вниз - рисование во время движения.

turtle.penup()

turtle.pu()

turtle.up()

Потяните ручку вверх - никакого рисования при движении.

turtle.pensize(width=None)

turtle.width(width=None)

Параметры:

width – положительное число

Установите толщину линии равной width или верните ее. Если для resizemode установлено значение «auto» и черепаховая форма является многоугольником, то этот многоугольник рисуется с той же толщиной линии. Если аргумент не указан, возвращается текущий размер ручки.

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn

turtle.pen(pen=None, **pendict)

Параметры:

• pen – словарь с некоторыми или всеми перечисленными ниже ключами

• pendict – один или несколько ключевых слов-аргументов с перечисленными ниже ключами в качестве ключевых слов

Возвращает или задает атрибуты пера в «словаре пера» со следующими парами ключ/значение:

• «показано»: Правда/Ложь

• «pendown»: Правда/Ложь

• «pencolor»: цвет-строка или цвет-кортеж

• «fillcolor»: цвет-строка или цвет-кортеж

• «размер ручки»: положительное число

• «скорость»: число в диапазоне 0..10

• «resizemode»: «auto» или «user» или «noresize»

• «коэффициент растяжения»: (положительное число, положительное число)

• «контур»: положительное число

• «наклон»: число

Этот словарь может быть использован в качестве аргумента для последующего вызова pen() для восстановления прежнего состояния пера. Кроме того, один или несколько атрибутов могут быть предоставлены в качестве ключевых слов-аргументов. Это может быть использовано для установки нескольких атрибутов пера в одном операторе.

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

Возвращает True, если ручка опущена, False, если поднята.

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

Управление цветом

turtle.pencolor(*args)

Возвращает или устанавливает цвет карандаша.

Допускается использование четырех форматов входного сигнала:

pencolor()

Возвращает текущий цвет карандаша в виде строки спецификации цвета или в виде кортежа (см. пример). Может использоваться в качестве входных данных для другого вызова color/pencolor/fillcolor.

pencolor(colorstring)

Установите pencolor на colorstring, которая представляет собой строку спецификации цвета Tk, например "red", "yellow" или "#33cc8c".

pencolor((r, g, b))

Установите pencolor на цвет RGB, представленный кортежем из r, g и b. Каждый из r, g и b должен находиться в диапазоне 0…colormode, где colormode - 1.0 или 255 (см. colormode()).

pencolor(r, g, b)

Установите pencolor на цвет RGB, представленный r, g и b. Каждый из r, g и b должен находиться в диапазоне 0…colormode.

Если turtleshape - это многоугольник, то контур этого многоугольника будет нарисован новым установленным цветом карандаша.

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

Возвращает или устанавливает цвет заливки.

Допускается использование четырех форматов входного сигнала:

fillcolor()

Возвращает текущий цвет заливки в виде строки спецификации цвета, возможно, в формате кортежа (см. пример). Может использоваться в качестве входных данных для другого вызова color/pencolor/fillcolor.

fillcolor(colorstring)

Установите fillcolor в colorstring, которая представляет собой строку спецификации цвета Tk, например "red", "yellow" или "#33cc8c".

fillcolor((r, g, b))

Установите fillcolor в цвет RGB, представленный кортежем из r, g и b. Каждое из r, g и b должно находиться в диапазоне 0..colormode, где colormode равно 1.0 или 255 (см. colormode()).

fillcolor(r, g, b)

Установите fillcolor в цвет RGB, представленный r, g и b. Каждый из r, g и b должен находиться в диапазоне 0…colormode.

Если turtleshape - это многоугольник, то внутренняя часть этого многоугольника рисуется с вновь установленным цветом заливки.

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

Возвращает или устанавливает цвет карандаша и цвет заливки.

Допускается несколько форматов ввода. Они используют от 0 до 3 аргументов следующим образом:

color()

Возвращает текущий цвет карандаша и текущий цвет заливки в виде пары строк или кортежей спецификаций цвета, как возвращается pencolor() и fillcolor().

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

Вводятся как в pencolor(), устанавливают оба цвета, fillcolor и pencolor, в заданное значение.

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

Эквивалентно pencolor(colorstring1) и fillcolor(colorstring2) и аналогично, если используется другой формат ввода.

Если фигура черепахи является многоугольником, то контур и внутренняя часть многоугольника рисуются с использованием вновь установленных цветов.

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

См. также: Метод экрана colormode().

Наполнение

turtle.filling()

Возвращает состояние заполнения (True при заполнении, False в противном случае).

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

turtle.begin_fill()

Вызывается непосредственно перед рисованием фигуры, которую нужно заполнить.

turtle.end_fill()

Заполните фигуру, нарисованную после последнего обращения к begin_fill().

Заливаются ли области перекрытия для самопересекающихся многоугольников или нескольких фигур, зависит от графики операционной системы, типа перекрытия и количества перекрытий. Например, звезда Черепахи, изображенная выше, может быть либо полностью желтой, либо иметь несколько белых областей.

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

Больше контроля над рисунком

turtle.reset()

Удалите рисунки черепахи с экрана, заново отцентрируйте черепаху и установите переменные на значения по умолчанию.

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

Удалите рисунки черепахи с экрана. Не перемещайте черепаху. Состояние и положение черепахи, а также рисунки других черепах не затрагиваются.

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

Параметры:

• arg – объект для записи на экран TurtleScreen

• move – Правда/Ложь

• align – одна из строк «left», «center» или right».

• font – тройка (fontname, fontsize, fonttype)

Напишите текст - строковое представление arg - в текущей позиции черепашки в соответствии с align («слева», «по центру» или «справа») и заданным шрифтом. Если move равно true, перо перемещается в правый нижний угол текста. По умолчанию значение move равно False.

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

Состояние черепахи

Видимость

turtle.hideturtle()

turtle.ht()

Сделайте черепашку невидимой. Это стоит сделать, пока вы занимаетесь сложным рисунком, потому что скрытие черепашки заметно ускоряет процесс рисования.

>>> turtle.hideturtle()

turtle.showturtle()

turtle.st()

Сделайте черепаху видимой.

>>> turtle.showturtle()

turtle.isvisible()

Возвращает True, если черепаха показана, False, если она скрыта.

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

Внешний вид

turtle.shape(name=None)

Параметры:

name – строка, которая является действительным именем формы

Устанавливает форму черепахи в форму с заданным именем или, если имя не задано, возвращает имя текущей формы. Фигура с именем name должна существовать в словаре фигур TurtleScreen. Изначально существуют следующие многоугольные фигуры: «стрела», «черепаха», «круг», «квадрат», «треугольник», «классика». О том, как работать с фигурами, читайте в разделе Метод экрана register_shape().

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'

turtle.resizemode(rmode=None)

Параметры:

rmode – одна из строк «auto», «user», «noresize»

Установите resizemode в одно из значений: «auto», «user», «noresize». Если значение rmode не задано, возвращается текущий resizemode. Различные режимы изменения размеров имеют следующие эффекты:

• «auto»: адаптирует внешний вид черепашки в соответствии со значением параметра pensize.

• «user»: адаптирует внешний вид черепашки в соответствии со значениями stretchfactor и outlinewidth (контур), которые задаются shapesize().

• «noresize»: адаптация внешнего вида черепахи не происходит.

resizemode("user") вызывается shapesize(), когда используется с аргументами.

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

Параметры:

• stretch_wid – положительное число

• stretch_len – положительное число

• outline – положительное число

Возвращает или устанавливает атрибуты пера x/y-факторы растяжения и/или контур. Установите значение resizemode на «user». Если и только если для resizemode установлено значение «user», черепаха будет отображаться растянутой в соответствии с ее коэффициентами растяжения: stretch_wid - коэффициент растяжения перпендикулярно ориентации, stretch_len - коэффициент растяжения в направлении ориентации, outline определяет ширину контура фигуры.

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

Параметры:

shear – число (необязательно)

Устанавливает или возвращает текущий коэффициент сдвига. Стрижет черепашью фигуру в соответствии с заданным коэффициентом сдвига shear, который является тангенсом угла сдвига. Не изменяет курс (направление движения) черепахи. Если значение shear не задано: возвращается текущий коэффициент сдвига, то есть тангенс угла сдвига, на который сдвигаются линии, параллельные курсу черепахи.

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

turtle.tilt(angle)

Параметры:

angle – число

Поверните фигуру черепахи на угол относительно ее текущего угла наклона, но не изменяйте направление движения черепахи.

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

Параметры:

angle – число (необязательно)

Устанавливает или возвращает текущий угол наклона. Если задан угол, поверните черепашку в направлении, указанном углом, независимо от ее текущего угла наклона. Не изменяет направление (направление движения) черепахи. Если угол не задан: возвращает текущий угол наклона, то есть угол между ориентацией фигуры черепашки и ее курсом (направлением движения).

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

Параметры:

• t11 – число (необязательно)

• t12 – число (необязательно)

• t21 – число (необязательно)

• t12 – число (необязательно)

Устанавливает или возвращает текущую матрицу трансформации формы черепахи.

Если ни один из элементов матрицы не задан, верните матрицу преобразования в виде кортежа из 4 элементов. В противном случае установите заданные элементы и преобразуйте черепаховую фигуру в соответствии с матрицей, состоящей из первой строки t11, t12 и второй строки t21, t22. Определитель t11 * t22 - t12 * t21 не должен быть нулевым, иначе будет выдана ошибка. Измените коэффициент растяжения, коэффициент сдвига и угол наклона в соответствии с заданной матрицей.

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

Возвращает текущий многоугольник фигуры в виде кортежа пар координат. Это можно использовать для определения новой фигуры или компонентов составной фигуры.

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

Использование событий

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

Параметры:

• fun – функция с двумя аргументами, которая будет вызвана с координатами точки щелчка на холсте

• btn – номер кнопки мыши, по умолчанию 1 (левая кнопка мыши)

• add – True или False – если True, будет добавлена новая привязка, в противном случае она заменит прежнюю привязку

Привяжите fun к событиям нажатия мыши на этой черепахе. Если fun равно None, существующие привязки удаляются. Пример для анонимной черепахи, т.е. процедурный способ:

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

Параметры:

• fun – функция с двумя аргументами, которая будет вызвана с координатами точки щелчка на холсте

• btn – номер кнопки мыши, по умолчанию 1 (левая кнопка мыши)

• add – True или False – если True, будет добавлена новая привязка, в противном случае она заменит прежнюю привязку

Привяжите fun к событиям отпускания кнопки мыши на этой черепахе. Если fun равно None, существующие привязки будут удалены.

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

Параметры:

• fun – функция с двумя аргументами, которая будет вызвана с координатами точки щелчка на холсте

• btn – номер кнопки мыши, по умолчанию 1 (левая кнопка мыши)

• add – True или False – если True, будет добавлена новая привязка, в противном случае она заменит прежнюю привязку

Привязать fun к событиям перемещения мыши на этой черепахе. Если fun равно None, существующие привязки будут удалены.

Замечание: Каждой последовательности событий перемещения мыши по черепахе предшествует событие щелчка мыши по этой черепахе.

>>> turtle.ondrag(turtle.goto)

Впоследствии, нажимая и перетаскивая черепашку, можно перемещать ее по экрану, создавая рисунки от руки (если перо опущено).

Специальные методы черепахи

turtle.begin_poly()

Начните записывать вершины многоугольника. Текущая позиция черепахи - первая вершина многоугольника.

turtle.end_poly()

Остановите запись вершин многоугольника. Текущая позиция черепашки - последняя вершина многоугольника. Она будет соединена с первой вершиной.

turtle.get_poly()

Возвращает последний записанный полигон.

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

Создайте и верните клон черепахи с той же позицией, направлением и свойствами черепахи.

>>> mick = Turtle()
>>> joe = mick.clone()

turtle.getturtle()

turtle.getpen()

Возвращает сам объект Turtle. Единственное разумное применение: в качестве функции для возврата «анонимной черепахи»:

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

turtle.getscreen()

Возвращает объект TurtleScreen, на котором рисует черепаха. Методы TurtleScreen могут быть вызваны для этого объекта.

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

turtle.setundobuffer(size)

Параметры:

size – целое число или None

Установка или отключение недобуфера. Если size - целое число, устанавливается пустой undobuffer заданного размера. size задает максимальное количество действий черепашки, которые могут быть отменены методом/функцией undo(). Если size равен None, недобуфер отключается.

>>> turtle.setundobuffer(42)

turtle.undobufferentries()

Возвращает количество записей в недобуфере.

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

Составные фигуры

Чтобы использовать составные черепашьи фигуры, состоящие из нескольких многоугольников разного цвета, необходимо явно использовать вспомогательный класс Shape, как описано ниже:

1. Создайте пустой объект Shape типа «compound».

2. Добавьте к этому объекту столько компонентов, сколько необходимо, используя метод addcomponent().

   Например:

   >>> 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. Теперь добавьте фигуру в список фигур экрана и используйте ее:

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

Примечание

Класс Shape используется внутри метода register_shape() различными способами. Прикладной программист должен иметь дело с классом Shape только при использовании составных фигур, как показано выше!

Методы TurtleScreen/Screen и соответствующие функции

Большинство примеров в этом разделе относятся к экземпляру TurtleScreen с именем screen.

Управление окнами

turtle.bgcolor(*args)

Параметры:

args – строка цвета или три числа в диапазоне 0…colormode или 3 кортежа таких чисел

Устанавливает или возвращает цвет фона экрана TurtleScreen.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)

turtle.bgpic(picname=None)

Параметры:

picname – строка, имя gif-файла или "nopic", или None.

Устанавливает фоновое изображение или возвращает имя текущего фонового изображения. Если picname - это имя файла, установите соответствующее изображение в качестве фона. Если picname равно "nopic", удалите фоновое изображение, если оно присутствует. Если picname равно None, возвращается имя файла текущего фонового изображения.

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

turtle.clear()

Примечание

Этот метод TurtleScreen доступен в качестве глобальной функции только под именем clearscreen. Глобальная функция clear - это другая функция, полученная из метода Turtle clear.

turtle.clearscreen()

Удалите все рисунки и всех черепах с экрана TurtleScreen. Верните пустой TurtleScreen в исходное состояние: белый фон, отсутствие фонового изображения, отсутствие привязки к событиям и включенной трассировки.

turtle.reset()

Примечание

Этот метод TurtleScreen доступен в качестве глобальной функции только под именем resetscreen. Глобальная функция reset - это еще одна функция, производная от метода Turtle reset.

turtle.resetscreen()

Верните всех черепах на экране в исходное состояние.

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

Параметры:

• canvwidth – целое положительное число, новая ширина холста в пикселях

• canvheight – целое положительное число, новая высота холста в пикселях

• bg – colorstring или color-tuple, новый цвет фона

Если аргументы не заданы, возвращается текущее значение (canvaswidth, canvasheight). Иначе измените размер холста, на котором рисуют черепашки. Не изменяйте окно рисования. Чтобы увидеть скрытые части холста, используйте полосы прокрутки. С помощью этого метода можно сделать видимыми те части рисунка, которые раньше находились за пределами холста.

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

Например, для поиска ошибочно сбежавшей черепахи ;-)

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

Параметры:

• llx – число, x-координата левого нижнего угла холста

• lly – число, y-координата левого нижнего угла холста

• urx – число, x-координата правого верхнего угла холста

• ury – число, y-координата правого верхнего угла холста

Установите пользовательскую систему координат и при необходимости переключитесь в режим «мир». При этом выполняется операция screen.reset(). Если режим «мир» уже активен, все рисунки перерисовываются в соответствии с новыми координатами.

ПРИМЕЧАНИЕ: в пользовательских системах координат углы могут выглядеть искаженными.

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

Управление анимацией

turtle.delay(delay=None)

Параметры:

delay – целое положительное число

Устанавливает или возвращает задержку рисования в миллисекундах. (Это примерно интервал времени между двумя последовательными обновлениями холста). Чем больше задержка отрисовки, тем медленнее анимация.

Необязательный аргумент:

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5

turtle.tracer(n=None, delay=None)

Параметры:

• n – целое неотрицательное число

• delay – целое неотрицательное число

Включает/выключает анимацию черепахи и устанавливает задержку обновления рисунков. Если задано n, то реально выполняется только каждое n-е регулярное обновление экрана. (Может использоваться для ускорения отрисовки сложной графики). При вызове без аргументов возвращает текущее хранящееся значение n. Второй аргумент задает значение задержки (см. delay()).

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

turtle.update()

Выполнить обновление TurtleScreen. Используется, когда трассировщик выключен.

См. также метод RawTurtle/Turtle speed().

Использование событий экрана

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

Устанавливает фокус на TurtleScreen (чтобы собирать ключевые события). Фиктивные аргументы предоставлены для того, чтобы можно было передать listen() в метод onclick.

turtle.onkey(fun, key)

turtle.onkeyrelease(fun, key)

Параметры:

• fun – функция без аргументов или None

• key – строка: ключ (например, «a») или ключ-символ (например, «пробел»)

Привязка fun к событию key-release клавиши. Если fun равно None, привязка к событию снимается. Примечание: чтобы иметь возможность регистрировать события нажатия клавиш, TurtleScreen должен иметь фокус. (См. метод listen()).

>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()

turtle.onkeypress(fun, key=None)

Параметры:

• fun – функция без аргументов или None

• key – строка: ключ (например, «a») или ключ-символ (например, «пробел»)

Привяжите fun к событию нажатия клавиши, если клавиша задана, или к любому событию нажатия клавиши, если клавиша не задана. Примечание: чтобы иметь возможность регистрировать события нажатия клавиш, TurtleScreen должен иметь фокус. (См. метод 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)

Параметры:

• fun – функция с двумя аргументами, которая будет вызвана с координатами точки щелчка на холсте

• btn – номер кнопки мыши, по умолчанию 1 (левая кнопка мыши)

• add – True или False – если True, будет добавлена новая привязка, в противном случае она заменит прежнюю привязку

Привяжите fun к событиям нажатия мыши на этом экране. Если fun равно None, существующие привязки будут удалены.

Пример для экземпляра TurtleScreen с именем screen и экземпляра Turtle с именем 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

Примечание

Этот метод TurtleScreen доступен в качестве глобальной функции только под именем onscreenclick. Глобальная функция onclick - это еще одна функция, производная от метода Turtle onclick.

turtle.ontimer(fun, t=0)

Параметры:

• fun – функция без аргументов

• t – число >= 0

Установите таймер, который вызывает fun через t миллисекунд.

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

Запускает цикл событий - вызывает функцию mainloop в Tkinter. Должен быть последним оператором в программе с черепашьей графикой. Не должно использоваться, если скрипт запускается из IDLE в режиме -n (No subprocess) - для интерактивного использования черепашьей графики.

>>> screen.mainloop()

Методы ввода

turtle.textinput(title, prompt)

Параметры:

• title – строка

• prompt – строка

Выводит диалоговое окно для ввода строки. Параметр title - заголовок диалогового окна, prompt - текст, описывающий, какую информацию нужно ввести. Возвращает введенную строку. Если диалог отменен, возвращается None.

>>> screen.textinput("NIM", "Name of first player:")

turtle.numinput(title, prompt, default=None, minval=None, maxval=None)

Параметры:

• title – строка

• prompt – строка

• default – число (необязательно)

• minval – число (необязательно)

• maxval – число (необязательно)

Выводит диалоговое окно для ввода числа. title - заголовок диалогового окна, prompt - текст, описывающий, какую числовую информацию нужно ввести. default: значение по умолчанию, minval: минимальное значение для ввода, maxval: максимальное значение для ввода. Вводимое число должно находиться в диапазоне minval … maxval, если они заданы. Если это не так, выдается подсказка, и диалог остается открытым для исправления. Вернуть введенное число. Если диалог отменен, верните None.

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

Настройки и специальные методы

turtle.mode(mode=None)

Параметры:

mode – одна из строк «standard», «logo» или «world».

Установите режим черепашки («стандартный», «логотип» или «мир») и выполните сброс. Если режим не задан, возвращается текущий режим.

Режим «стандарт» совместим со старыми turtle. Режим «logo» совместим с большинством графических черепах Logo. Режим «world» использует заданные пользователем «мировые координаты». Внимание: в этом режиме углы отображаются искаженными, если соотношение единиц x/y не равно 1.

Режим	Начальный курс черепахи	положительные углы
«стандарт»	направо (на восток)	против часовой стрелки
«логотип»	вверх (север)	по часовой стрелке

>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'

turtle.colormode(cmode=None)

Параметры:

cmode – одно из значений 1.0 или 255

Возвращает цветовой режим или устанавливает его в значение 1.0 или 255. В дальнейшем значения r, g, b цветовых троек должны находиться в диапазоне 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()

Возвращает Canvas этого TurtleScreen. Полезно для инсайдеров, которые знают, что делать с Tkinter Canvas.

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

turtle.getshapes()

Возвращает список имен всех доступных на данный момент фигур черепахи.

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']

turtle.register_shape(name, shape=None)

turtle.addshape(name, shape=None)

Вызвать эту функцию можно тремя разными способами:

1. name - это имя gif-файла, а shape - None: Установите соответствующую форму изображения.

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

   Примечание

   Фигуры изображений не вращаются при повороте черепахи, поэтому они не отображают направление движения черепахи!

2. name - произвольная строка, а shape - кортеж из пар координат: Установите соответствующую форму многоугольника.

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

3. name - произвольная строка, а shape - объект (составной) Shape: Установите соответствующую составную форму.

Добавляет фигуру черепахи в список фигур TurtleScreen. Только зарегистрированные таким образом фигуры можно использовать, выполнив команду shape(shapename).

turtle.turtles()

Верните список черепах на экран.

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

turtle.window_height()

Возвращает высоту окна черепахи.

>>> screen.window_height()
480

turtle.window_width()

Возвращает ширину окна черепашки.

>>> screen.window_width()
640

Методы, специфичные для Screen, не наследуются от TurtleScreen

turtle.bye()

Закройте окно туртелеграфа.

turtle.exitonclick()

Привяжите метод bye() к щелчкам мыши на экране.

Если значение «using_IDLE» в словаре конфигурации равно False (значение по умолчанию), также войдите в mainloop. Замечание: Если используется IDLE с ключом -n (без подпроцесса), это значение должно быть установлено в True в turtle.cfg. В этом случае собственный mainloop IDLE будет активен и для клиентского скрипта.

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

Устанавливает размер и положение главного окна. Значения аргументов по умолчанию хранятся в словаре конфигурации и могут быть изменены через файл turtle.cfg.

Параметры:

• width – если целое число, то размер в пикселях, если float, то доля экрана; по умолчанию 50% экрана

• height – если целое число, то высота в пикселях, если float, то доля от экрана; по умолчанию 75% от экрана

• startx – если положительный, начальная позиция в пикселях от левого края экрана, если отрицательный - от правого края, если None, центрирует окно по горизонтали

• starty – если положительный, начальная позиция в пикселях от верхнего края экрана, если отрицательный - от нижнего края, если None, центрирует окно по вертикали

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

Параметры:

titlestring – строка, которая отображается в строке заголовка графического окна черепахи

Установите заголовок окна черепашки на titlestring.

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

Публичные классы

class turtle.RawTurtle(canvas)

class turtle.RawPen(canvas)

Параметры:

canvas – tkinter.Canvas, ScrolledCanvas или TurtleScreen.

Создайте черепаху. Черепаха имеет все методы, описанные выше как «методы Turtle/RawTurtle».

class turtle.Turtle

Подкласс RawTurtle, имеет тот же интерфейс, но рисует на объекте по умолчанию Screen, который создается автоматически при первом использовании.

class turtle.TurtleScreen(cv)

Параметры:

cv – a tkinter.Canvas

Предоставляет методы, ориентированные на экран, такие как bgcolor() и т.д., которые описаны выше.

class turtle.Screen

Подкласс TurtleScreen, с four methods added.

class turtle.ScrolledCanvas(master)

Параметры:

master – некоторый виджет Tkinter, содержащий ScrolledCanvas, т.е. Tkinter-канву с добавленными полосами прокрутки

Используется классом Screen, который таким образом автоматически предоставляет ScrolledCanvas в качестве игровой площадки для черепашек.

class turtle.Shape(type_, data)

Параметры:

type_ – одна из строк «polygon», «image», «compound»

Формы моделирования структуры данных. Пара (type_, data) должна соответствовать этой спецификации:

тип_	данные
«полигон»	кортеж полигонов, т.е. кортеж пар координат
«изображение»	изображение (в этом виде используется только внутри страны!)
«состав»	None (составная фигура должна быть построена с помощью метода addcomponent())

addcomponent(poly, fill, outline=None)

Параметры:

• poly – многоугольник, т.е. кортеж из пар чисел

• fill – цвет, которым будет заполнена поли

• outline – цвет для контура поли (если задан)

Пример:

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

См. Составные фигуры.

class turtle.Vec2D(x, y)

Класс двумерных векторов, используемый в качестве вспомогательного класса для реализации черепашьей графики. Может быть полезен и для программ черепашьей графики. Производный от tuple, так что вектор - это кортеж!

Обеспечивает (для векторов a, b, k число):

• a + b векторное сложение

• a - b векторное вычитание

• Внутреннее произведение a * b

• Умножение k * a и a * k на скалярное

• abs(a) абсолютное значение

• Вращение a.rotate(angle)

Пояснение

Объект черепахи рисует на объекте экрана, и в объектно-ориентированном интерфейсе черепахи есть несколько ключевых классов, которые можно использовать для их создания и связи друг с другом.

Экземпляр Turtle автоматически создает экземпляр Screen, если его еще нет.

Turtle является подклассом RawTurtle, который не автоматически создает поверхность для рисования - для него необходимо предоставить или создать канву. Холст* может быть tkinter.Canvas, ScrolledCanvas или TurtleScreen.

TurtleScreen - это базовая поверхность для рисования черепахи. Screen является подклассом TurtleScreen и включает some additional methods для управления внешним видом (включая размер и заголовок) и поведением. Конструктор TurtleScreen требует в качестве аргумента tkinter.Canvas или ScrolledCanvas.

Функциональный интерфейс для черепашьей графики использует различные методы Turtle и TurtleScreen/Screen. За кулисами объект screen автоматически создается всякий раз, когда вызывается функция, производная от метода Screen. Аналогично, объект черепахи автоматически создается при вызове любой из функций, производных от метода Turtle.

Чтобы использовать несколько черепах на экране, необходимо использовать объектно-ориентированный интерфейс.

Помощь и настройка

Как использовать помощь

Публичные методы классов Screen и Turtle подробно описаны в документах. Поэтому их можно использовать в качестве онлайн-справки с помощью средств помощи Python:

• При использовании IDLE всплывающие подсказки показывают подписи и первые строки документальных строк вводимых вызовов функций/методов.

• Вызов help() в методах или функциях выводит на экран документацию:

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

• Докстринги функций, которые являются производными от методов, имеют измененный вид:

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

Эти модифицированные документообороты создаются автоматически вместе с определениями функций, которые получаются из методов во время импорта.

Перевод документальных строк на разные языки

Имеется утилита для создания словаря, ключами которого являются имена методов, а значениями - документированные строки открытых методов классов Screen и Turtle.

turtle.write_docstringdict(filename='turtle_docstringdict')

Параметры:

filename – строка, используемая в качестве имени файла

Создает и записывает docstring-словарь в Python-скрипт с заданным именем файла. Эта функция должна быть вызвана явно (она не используется графическими классами черепахи). Словарь docstring будет записан в Python-скрипт filename.py. Он должен служить шаблоном для перевода doc-строк на разные языки.

Если вы (или ваши ученики) хотите использовать turtle с онлайн-справкой на вашем родном языке, вам нужно будет перевести docstrings и сохранить полученный файл как, например, turtle_docstringdict_german.py.

Если в вашем файле turtle.cfg есть соответствующая запись, то этот словарь будет считан при импорте и заменит оригинальные английские документы.

На момент написания этой статьи существуют словари docstring на немецком и итальянском языках. (Просьбы направлять на glingl@aon.at.)

Как настроить «Экран и черепахи

Встроенная конфигурация по умолчанию имитирует внешний вид и поведение старого модуля turtle, чтобы сохранить максимальную совместимость с ним.

Если вы хотите использовать другую конфигурацию, которая лучше отражает возможности этого модуля или лучше соответствует вашим потребностям, например, для использования в классе, вы можете подготовить файл конфигурации turtle.cfg, который будет считываться при импорте, и изменить конфигурацию в соответствии с его настройками.

Встроенная конфигурация будет соответствовать следующим 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

Краткие пояснения к избранным статьям:

• Первые четыре строки соответствуют аргументам метода Screen.setup.

• Строки 5 и 6 соответствуют аргументам метода Screen.screensize.

• shape может быть любой из встроенных фигур, например: стрела, черепаха и т.д. Для получения дополнительной информации попробуйте help(shape).

• Если вы хотите не использовать цвет заливки (т.е. сделать черепашку прозрачной), нужно написать fillcolor = "" (но все непустые строки в cfg-файле не должны иметь кавычек).

• Если вы хотите отразить состояние черепахи, используйте resizemode = auto.

• Если вы зададите, например, language = italian, то во время импорта будет загружен docstringdict turtle_docstringdict_italian.py (если он присутствует на пути импорта, например, в том же каталоге, что и turtle).

• Записи exampleturtle и examplescreen определяют имена этих объектов в том виде, в котором они встречаются в документах. Преобразование докстрингов методов в докстринги функций удалит эти имена из докстрингов.

• using_IDLE: Установите это значение в True, если вы регулярно работаете с IDLE и его переключателем -n («без подпроцесса»). Это предотвратит попадание exitonclick() в основной цикл.

Файл turtle.cfg может находиться в каталоге, где хранится turtle, а дополнительный - в текущем рабочем каталоге. Последний отменяет настройки первого.

В каталоге Lib/turtledemo находится файл turtle.cfg. Вы можете изучить его в качестве примера и увидеть его эффекты при запуске демо-версий (желательно не из программы просмотра демо-версий).

turtledemo — Демо-скрипты

В пакет turtledemo входит набор демонстрационных скриптов. Эти скрипты можно запустить и просмотреть с помощью прилагаемой программы просмотра демо-версий следующим образом:

python -m turtledemo

Кроме того, вы можете запускать демонстрационные скрипты по отдельности. Например,

python -m turtledemo.bytedesign

Каталог пакетов turtledemo содержит:

• Демо-просмотрщик __main__.py, который можно использовать для просмотра исходного кода скриптов и их одновременного запуска.

• Несколько скриптов, демонстрирующих различные возможности модуля turtle. Доступ к примерам можно получить через меню Примеры. Их также можно запускать автономно.

• Файл turtle.cfg, который служит примером того, как писать и использовать такие файлы.

Демо-скрипты:

Имя	Описание	Характеристики
bytedesign	Сложный классический графический рисунок черепахи	tracer(), задержка, update()
хаос	Графики динамики Верхульста показывают, что компьютерные вычисления могут давать результаты, иногда противоречащие ожиданиям здравого смысла.	мировые координаты
часы	Аналоговые часы, показывающие время на вашем компьютере	черепахи в качестве стрелок часов, ontimer
колормиксер	экспериментируйте с r, g, b	ondrag()
лес	3 дерева с широким охватом	рандомизация
фрактальные кривые	Кривые Гильберта и Коха	рекурсия
линденмайер	Этноматематика (индийские коламы)	L-System
minimal_hanoi	Башни Ханоя	Прямоугольные черепахи в виде ханойских дисков (форма, размер)
nim	Играйте в классическую игру nim с тремя кучками палочек против компьютера.	Черепашки как палочки, управляемые событиями (мышь, клавиатура)
краска	Суперминималистичная программа для рисования	onclick()
мир	элементарный	Черепаха: внешний вид и анимация
Пенроуз	апериодическая плитка с воздушными змеями и дротиками	stamp()
планета_и_луна	моделирование гравитационной системы	составные фигуры, Vec2D
розочка	рисунок из статьи википедии о черепаховой графике	clone(), undo()
хоровод	Танцующие черепахи, вращающиеся парами в противоположном направлении	составные фигуры, клонировать фигуры, наклон, get_shapepoly, обновить
сортировка_одушевлённых	наглядная демонстрация различных методов сортировки	Простое выравнивание, рандомизация
дерево	(графическое) дерево первой ширины (с использованием генераторов)	clone()
two_canvases	простой дизайн	Черепахи на двух холстах
Иньян	еще один элементарный пример	circle()

Веселитесь!

Изменения с Python 2.6

• Методы Turtle.tracer, Turtle.window_width и Turtle.window_height были упразднены. Методы с такими именами и функциональностью теперь доступны только в качестве методов Screen. Функции, производные от них, остаются доступными. (Фактически уже в Python 2.6 эти методы были просто дубликатами соответствующих методов TurtleScreen/Screen).

• Метод Turtle.fill() был упразднен. Поведение begin_fill() и end_fill() немного изменилось: теперь каждый процесс заполнения должен завершаться вызовом end_fill().

• Был добавлен метод Turtle.filling. Он возвращает булево значение: True, если идет процесс заполнения, False - в противном случае. Такое поведение соответствует вызову fill() без аргументов в Python 2.6.

Изменения с Python 3.0

• Добавлены методы Turtle shearfactor(), shapetransform() и get_shapepoly(). Таким образом, теперь для преобразования фигур черепашек доступен весь спектр регулярных линейных преобразований. Функциональность метода tiltangle() была расширена: теперь он может использоваться для получения или установки угла наклона.

• Метод Screen onkeypress() был добавлен в качестве дополнения к onkey(). Поскольку последний привязывает действия к событию отпускания клавиши, для него также был добавлен псевдоним onkeyrelease().

• Был добавлен метод Screen.mainloop, поэтому больше нет необходимости использовать отдельную функцию mainloop() при работе с объектами Screen и Turtle.

• Добавлены два метода ввода: Screen.textinput и Screen.numinput. Они вызывают диалоговые окна ввода и возвращают строки и числа соответственно.

• Два примера скриптов tdemo_nim.py и tdemo_round_dance.py были добавлены в каталог Lib/turtledemo.