`turtle` — Графіка черепахи¶

Вихідний код: Lib/turtle.py

Вступ¶

Turtle graphics is an implementation of the popular geometric drawing tools introduced in Logo, developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

In Python, turtle graphics provides a representation of a physical «turtle» (a little robot with a pen) that draws on a sheet of paper on the floor.

It’s an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback. It also provides convenient access to graphical output in general.

Turtle drawing was originally created as an educational tool, to be used by teachers in the classroom. For the programmer who needs to produce some graphical output it can be a way to do that without the overhead of introducing more complex or external libraries into their work.

Підручник¶

New users should start here. In this tutorial we’ll explore some of the basics of turtle drawing.

Starting a turtle environment¶

In a Python shell, import all the objects of the `turtle` module:

```from turtle import *
```

If you run into a `No module named '_tkinter'` error, you’ll have to install the `Tk interface package` on your system.

Basic drawing¶

Send the turtle forward 100 steps:

```forward(100)
```

You should see (most likely, in a new window on your display) a line drawn by the turtle, heading East. Change the direction of the turtle, so that it turns 120 degrees left (anti-clockwise):

```left(120)
```

Let’s continue by drawing a triangle:

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

Notice how the turtle, represented by an arrow, points in different directions as you steer it.

Experiment with those commands, and also with `backward()` and `right()`.

Керування пером¶

Try changing the color - for example, `color('blue')` - and width of the line - for example, `width(3)` - and then drawing again.

You can also move the turtle around without drawing, by lifting up the pen: `up()` before moving. To start drawing again, use `down()`.

The turtle’s position¶

Send your turtle back to its starting-point (useful if it has disappeared off-screen):

```home()
```

The home position is at the center of the turtle’s screen. If you ever need to know them, get the turtle’s x-y coordinates with:

```pos()
```

Home is at `(0, 0)`.

And after a while, it will probably help to clear the window so we can start anew:

```clearscreen()
```

Making algorithmic patterns¶

Using loops, it’s possible to build up geometric patterns:

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

- which of course, are limited only by the imagination!

Let’s draw the star shape at the top of this page. We want red lines, filled in with yellow:

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

Just as `up()` and `down()` determine whether lines will be drawn, filling can be turned on and off:

```begin_fill()
```

Next we’ll create a loop:

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

`abs(pos()) < 1` is a good way to know when the turtle is back at its home position.

Finally, complete the filling:

```end_fill()
```

(Note that filling only actually takes place when you give the `end_fill()` command.)

How to…¶

This section covers some typical turtle use-cases and approaches.

Get started as quickly as possible¶

One of the joys of turtle graphics is the immediate, visual feedback that’s available from simple commands - it’s an excellent way to introduce children to programming ideas, with a minimum of overhead (not just children, of course).

The turtle module makes this possible by exposing all its basic functionality as functions, available with `from turtle import *`. The turtle graphics tutorial covers this approach.

It’s worth noting that many of the turtle commands also have even more terse equivalents, such as `fd()` for `forward()`. These are especially useful when working with learners for whom typing is not a skill.

You’ll need to have the `Tk interface package` installed on your system for turtle graphics to work. Be warned that this is not always straightforward, so check this in advance if you’re planning to use turtle graphics with a learner.

Use the `turtle` module namespace¶

Using `from turtle import *` is convenient - but be warned that it imports a rather large collection of objects, and if you’re doing anything but turtle graphics you run the risk of a name conflict (this becomes even more an issue if you’re using turtle graphics in a script where other modules might be imported).

The solution is to use `import turtle` - `fd()` becomes `turtle.fd()`, `width()` becomes `turtle.width()` and so on. (If typing «turtle» over and over again becomes tedious, use for example ```import turtle as t``` instead.)

Use turtle graphics in a script¶

It’s recommended to use the `turtle` module namespace as described immediately above, for example:

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

Another step is also required though - as soon as the script ends, Python will also close the turtle’s window. Add:

```t.mainloop()
```

to the end of the script. The script will now wait to be dismissed and will not exit until it is terminated, for example by closing the turtle graphics window.

Use object-oriented turtle graphics¶

Other than for very basic introductory purposes, or for trying things out as quickly as possible, it’s more usual and much more powerful to use the object-oriented approach to turtle graphics. For example, this allows multiple turtles on screen at once.

In this approach, the various turtle commands are methods of objects (mostly of `Turtle` objects). You can use the object-oriented approach in the shell, but it would be more typical in a Python script.

The example above then becomes:

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

Note the last line. `t.screen` is an instance of the `Screen` that a Turtle instance exists on; it’s created automatically along with the turtle.

The turtle’s screen can be customised, for example:

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

Turtle graphics reference¶

Примітка

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

Методи черепахи¶

Рух черепахи
Рухайтесь і малюйте
Розкажіть про стан Черепахи
Налаштування та вимірювання
Керування пером
Стан малюнка
Контроль кольору
Наповнення
Більше контролю малювання
Держава черепахи
Видимість
Зовнішній вигляд
Використання подій
Спеціальні методи Черепахи

Методи TurtleScreen/Screen¶

Віконний контроль
Керування анімацією
Використання екранних подій
Налаштування та спеціальні методи
`висота_вікна()`
`ширина_вікна()`
Методи введення
Методи, специфічні для Screen

Методи RawTurtle/Turtle та відповідні функції¶

Більшість прикладів у цьому розділі стосуються екземпляра 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)
337.0
```
turtle.left(angle)
turtle.lt(angle)
Параметри:

angle – число (ціле чи з плаваючою точкою)

Поверніть черепаху ліворуч на кут. (За замовчуванням одиницями є градуси, але їх можна встановити за допомогою функцій `degrees()` і `radians()`.) Кутова орієнтація залежить від режиму черепахи, див. `mode()`.

```>>> turtle.heading()
22.0
>>> turtle.left(45)
67.0
```
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
Параметри:
• x – число або пара/вектор чисел

• y – число або `Жодного`

Якщо 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 – число або `Жодного`

• y – число або `Жодного`

• fill_gap – логічне значення

Move turtle to an absolute position. Unlike goto(x, y), a line will not be drawn. The turtle’s orientation does not change. If currently filling, the polygon(s) teleported from will be filled after leaving, and filling will begin again after teleporting. This can be disabled with fill_gap=True, which makes the imaginary line traveled during teleporting act as a fill barrier like in 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.seth(to_angle)
Параметри:

to_angle – число (ціле чи з плаваючою точкою)

Встановіть орієнтацію черепахи на to_angle. Ось кілька поширених напрямків у градусах:

стандартний режим

режим логотипу

0 - схід

0 - північ

90 - півн

90 - сх

180 - зах

180 - півд

270 - півд

270 - зах

```>>> turtle.setheading(90)
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)
0.0
```
Параметри:
• radius – число

• extent – число (або `Жодного`)

• steps – ціле число (або `Жодного`)

Накресліть коло із заданим радіусом. Центр — радіус одиниць ліворуч від черепахи; протяжність – кут – визначає, яка частина кола буде намальована. Якщо протяжність не вказано, намалюйте все коло. Якщо протяжність не є повним колом, одна кінцева точка дуги є поточною позицією пера. Намалюйте дугу проти годинникової стрілки, якщо радіус додатний, інакше – за годинниковою стрілкою. Нарешті, напрямок черепахи змінюється на величину протяжності.

Оскільки коло апроксимується вписаним правильним багатокутником, кроки визначають кількість кроків для використання. Якщо не вказано, воно буде розраховано автоматично. Можна використовувати для малювання правильних багатокутників.

```>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
180.0
```
turtle.dot(size=None, *color)
Параметри:
• size – ціле число >= 1 (якщо задано)

• 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)
0.0
```
turtle.stamp()

Виштампуйте копію фігури черепахи на полотні в поточній позиції черепахи. Повертає stamp_id для цього штампа, який можна використати для його видалення, викликавши `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 – ціле число (або `Жодного`)

Видалити всі або перші/останні 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 забезпечують дедалі швидшу анімацію малювання ліній і обертання черепахи.

Увага: швидкість = 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
```

Повертає поточний заголовок черепахи (значення залежить від режиму черепахи, див. `mode()`).

```>>> turtle.home()
>>> turtle.left(67)
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)
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)
100.0
>>> turtle.degrees(360)
90.0
```

Установіть одиниці вимірювання кута в радіанах. Еквівалент `градусів(2*math.pi)`.

```>>> turtle.home()
>>> turtle.left(90)
90.0
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» і turtleshape є багатокутником, цей багатокутник малюється з тією самою товщиною лінії. Якщо аргумент не задано, повертається поточний розмір пенсії.

```>>> 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»: кольоровий рядок або колірний кортеж

• «pensize»: позитивне число

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

• «resizemode»: «auto» або «user» або «noresize»

• «stretchfactor»: (додатне число, додатне число)

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

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

Цей словник можна використовувати як аргумент для наступного виклику `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, який є рядком специфікації кольору Tk, наприклад `"red"`, `"yellow"` або `"#33cc8c"`.

`` pencolor ((r, g, b))``

Встановіть колір пера на колір RGB, представлений кортежем r, g і b. Кожне з r, g і b має бути в діапазоні 0..colormode, де colormode дорівнює 1,0 або 255 (див. `colormode()`).

`колір пера(r, g, b)`

Встановіть колір пера на колір 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)`

Встановіть колір заливки на colorstring, який є рядком специфікації кольору Tk, наприклад `"red"`, `"yellow"` або `"#33cc8c"`.

`fillcolor((r, g, b))`

Встановіть колір заливки на колір RGB, представлений кортежем r, g і b. Кожне з r, g і b має бути в діапазоні 0..colormode, де colormode дорівнює 1,0 або 255 (див. `colormode()`).

`fillcolor(r, g, b)`

Встановіть колір заливки на колір 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 аргументів наступним чином:

`колір()`

Повертає поточний колір пера та поточний колір заливки як пару рядків специфікації кольору або кортежів, які повертає `pencolor()` і `fillcolor()`.

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

Вхідні дані, як у `pencolor()`, встановіть для обох, заливки та кольору пера, вказане значення.

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

Еквівалент `pencolor(colorstring1)` і `fillcolor(colorstring2)` і аналогічно, якщо використовується інший формат введення.

Якщо turtleshape є багатокутником, контур і внутрішня частина цього багатокутника малюються новими кольорами.

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

Повернути fillstate (`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)
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
0.0
```
turtle.clear()

Видаліть малюнки черепахи з екрана. Не рухай черепаху. Стан і положення черепахи, а також малюнки інших черепах не впливають.

turtle.write(arg, move=False, align='left', font=('Arial', 8, 'normal'))
Параметри:
• arg – об’єкт для запису на TurtleScreen

• move – Правда/Неправда

• align – один із рядків «зліва», «по центру» або справа»

• font – трійка (назва шрифту, розмір шрифту, тип шрифту)

Напишіть текст - рядкове представлення arg - у поточній позиції черепашки відповідно до align («left», «center» або «right») і з указаним шрифтом. Якщо 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 – рядок, який є дійсним іменем форми

Установити фігуру черепахи у форму з заданим ім’ям або, якщо ім’я не вказано, повернути назву поточної форми. Фігура з ім’ям має існувати в словнику форм TurtleScreen. Спочатку є такі форми багатокутників: «стрілка», «черепаха», «коло», «квадрат», «трикутник», «класика». Щоб дізнатися про те, як працювати з фігурами, перегляньте метод екрану `register_shape()`.

```>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
```
turtle.resizemode(rmode=None)
Параметри:

rmode – один із рядків «auto», «user», «noresize»

Встановіть для режиму зміни розміру одне зі значень: «авто», «користувач», «норесайз». Якщо rmode не вказано, повертає поточний режим зміни розміру. Різні режими зміни розміру мають такі ефекти:

• «авто»: адаптує зовнішній вигляд черепахи відповідно до значення 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 – позитивне число

Return or set the pen’s attributes x/y-stretchfactors and/or outline. Set resizemode to «user». If and only if resizemode is set to «user», the turtle will be displayed stretched according to its stretchfactors: stretch_wid is stretchfactor perpendicular to its orientation, stretch_len is stretchfactor in direction of its orientation, outline determines the width of the shape’s 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 – номер (необов’язково)

Встановити або повернути поточний коефіцієнт зсуву. Зрізайте форму черепахи відповідно до заданого коефіцієнта зсуву, який є тангенсом кута зсуву. Не змінюйте курс (напрямок руху) черепахи. Якщо зсув не вказано: повернути поточний коефіцієнт зсуву, тобто. д. тангенс кута зсуву, за яким зрізаються лінії, паралельні курсу черепахи.

```>>> 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.settiltangle(angle)
Параметри:

angle – число

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

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

Застаріло починаючи з версії 3.1.

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

Використання подій¶

Параметри:
• 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
```
Параметри:
• 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.
```
Параметри:
• 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()

Поверніть сам об’єкт Черепаха. Лише розумне використання: як функція для повернення «анонімної черепахи»:

```>>> 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 – ціле число або `Жодного`

Встановити або вимкнути undobuffer. Якщо size є цілим числом, встановлюється порожній undobuffer заданого розміру. size визначає максимальну кількість дій черепахи, які можна скасувати за допомогою методу/функції `undo()`. Якщо size має значення `None`, undobuffer вимкнено.

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

Повертає кількість записів у undobuffer.

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

Складені форми¶

Щоб використовувати складені форми черепахи, які складаються з кількох багатокутників різного кольору, ви повинні використовувати допоміжний клас `Shape` явно, як описано нижче:

1. Створіть порожній об’єкт Shape типу «compound».

2. Add as many components to this object as desired, using the `addcomponent()` method.

Наприклад:

```>>> 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 – рядок кольорів або кортеж кольорів, новий колір тла

Якщо аргументи не вказано, повертає поточний (ширина полотна, висота полотна). Інакше змініть розмір полотна, на якому малюють черепахи. Не змінюйте вікно малювання. Щоб спостерігати за прихованими частинами полотна, використовуйте смуги прокрутки. За допомогою цього методу можна зробити видимими ті частини малюнка, які раніше були за межами полотна.

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

напр. шукати черепаху, яка помилково втекла ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)
Параметри:
• llx – число, х-координата нижнього лівого кута полотна

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

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

• 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 до події звільнення ключа ключа. Якщо 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 до події натискання клавіші key, якщо клавішу вказано, або до будь-якої події натискання клавіші, якщо клавіша не вказана. Примітка: щоб мати можливість реєструвати ключові події, TurtleScreen повинен мати фокус. (Див. метод `listen()`.)

```>>> def f():
...     fd(50)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()
```
Параметри:
• 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()

Запускає цикл подій - виклик функції основного циклу Tkinter. Має бути останнім оператором у графічній програмі Turtle. Його не можна використовувати, якщо сценарій запускається з IDLE у режимі -n (без підпроцесу) — для інтерактивного використання черепахової графіки.

```>>> screen.mainloop()
```

Методи введення¶

turtle.textinput(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 – номер (необов’язково)

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

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

Налаштування та спеціальні методи¶

turtle.mode(mode=None)
Параметри:

mode – один із рядків «standard», «logo» або «world»

Встановіть режим черепахи («стандартний», «логотип» або «світ») і виконайте скидання. Якщо режим не вказано, повертається поточний режим.

Режим «стандартний» сумісний зі старим `turtle`. Режим «логотип» сумісний із більшістю зображень логотипів черепахи. Режим «світ» використовує визначені користувачем «світові координати». Увага: у цьому режимі кути виглядають спотвореними, якщо одиничне співвідношення `x/y` не дорівнює 1.

Режим

Початковий курс черепахи

позитивні кути

«стандарт»

праворуч (схід)

проти годинникової стрілки

«логотип»

вгору (на північ)

за годинниковою стрілкою

```>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
```
turtle.colormode(cmode=None)
Параметри:

cmode – одне зі значень 1,0 або 255

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

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

Поверніть 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)

Існує три різні способи виклику цієї функції:

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 is an arbitrary string and shape is a (compound) `Shape` object: Install the corresponding compound 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()

Закрийте вікно turtlegraphics.

turtle.exitonclick()

Прив’яжіть метод `bye()` до клацань миші на екрані.

Якщо значення «using_IDLE» у словнику конфігурації має значення `False` (значення за замовчуванням), також введіть mainloop. Примітка: якщо використовується IDLE з перемикачем `-n` (без підпроцесу), це значення має бути встановлено на `True` у `turtle.cfg`. У цьому випадку основний цикл IDLE також активний для клієнтського сценарію.

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

Встановіть розмір і положення головного вікна. Стандартні значення аргументів зберігаються у словнику конфігурації та можуть бути змінені за допомогою файлу `turtle.cfg`.

Параметри:
• width – якщо ціле число, то розмір у пікселях, якщо число з плаваючою точкою, то частка екрана; за замовчуванням 50% екрана

• height – якщо ціле число, то висота в пікселях, якщо число з плаваючою точкою, то частка екрана; за замовчуванням 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 – рядок, який відображається в рядку заголовка графічного вікна Turtle

Встановіть назву вікна Turtle на titlestring.

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

Публічні заняття¶

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
Параметри:

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

Створіть черепаху. Черепаха має всі методи, описані вище як «методи Turtle/RawTurtle».

class turtle.Turtle

Підклас RawTurtle має той самий інтерфейс, але використовує стандартний об’єкт `Screen`, створений автоматично, коли це потрібно вперше.

class turtle.TurtleScreen(cv)
Параметри:

cv – a `tkinter.Canvas`

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

class turtle.Screen

Підклас TurtleScreen із чотирма доданими методами.

class turtle.ScrolledCanvas(master)
Параметри:

master – деякий віджет Tkinter, який містить ScrolledCanvas, тобто Tkinter-полотно з доданими смугами прокрутки

Використовується класом Screen, який таким чином автоматично надає ScrolledCanvas як ігровий майданчик для черепах.

class turtle.Shape(type_, data)
Параметри:

type_ – один із рядків «polygon», «image», «compound»

Форми моделювання структури даних. Пара `(тип_, дані)` має відповідати цій специфікації:

тип_

дані

«багатокутник»

полігон-кортеж, тобто кортеж пар координат

«зображення»

зображення (у цій формі використовується лише внутрішньо!)

«з’єднання»

`None` (складена форма має бути створена за допомогою методу `addcomponent()`)

Параметри:
• poly – багатокутник, тобто кортеж пар чисел

• fill – колір, яким буде заповнено poly

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

Двовимірний векторний клас, який використовується як допоміжний клас для реалізації графіки черепахи. Також може бути корисним для графічних програм черепах. Походить від кортежу, тому вектор є кортежем!

Надає (для a, b векторів, k числа):

• `a + b` додавання вектора

• Віднімання вектора `a - b`

• `a * b` скалярний добуток

• Множення `k * a` і `a * k` на скаляр

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

• `a.rotate(angle)` обертання

Пояснення¶

A turtle object draws on a screen object, and there a number of key classes in the turtle object-oriented interface that can be used to create them and relate them to each other.

A `Turtle` instance will automatically create a `Screen` instance if one is not already present.

`Turtle` is a subclass of `RawTurtle`, which doesn’t automatically create a drawing surface - a canvas will need to be provided or created for it. The canvas can be a `tkinter.Canvas`, `ScrolledCanvas` or `TurtleScreen`.

`TurtleScreen` is the basic drawing surface for a turtle. `Screen` is a subclass of `TurtleScreen`, and includes some additional methods for managing its appearance (including size and title) and behaviour. `TurtleScreen`’s constructor needs a `tkinter.Canvas` or a `ScrolledCanvas` as an argument.

The functional interface for turtle graphics uses the various methods of `Turtle` and `TurtleScreen`/`Screen`. Behind the scenes, a screen object is automatically created whenever a function derived from a `Screen` method is called. Similarly, a turtle object is automatically created whenever any of the functions derived from a Turtle method is called.

To use multiple turtles on a screen, the object-oriented interface must be used.

Допомога та налаштування¶

Як користуватися довідкою¶

Загальнодоступні методи класів 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-dictionary у сценарій Python із вказаною назвою файлу. Цю функцію потрібно викликати явно (вона не використовується графічними класами turtle). Словник рядків документів буде записаний у сценарій Python `filename.py`. Він призначений для того, щоб служити шаблоном для перекладу рядків документів різними мовами.

Якщо ви (або ваші студенти) бажаєте використовувати `turtle` з онлайн-довідкою вашою рідною мовою, вам потрібно перекласти рядки документації та зберегти отриманий файл як, напр. `turtle_docstringdict_german.py`.

Якщо у вашому файлі `turtle.cfg` є відповідний запис, цей словник буде зчитано під час імпортування та замінить оригінальні англійські рядки документів.

На момент написання цієї статті існують словники docstring німецькою та італійською мовами. (Запити надсилайте на glingl@aon.at.)

Як налаштувати екран і черепахи¶

Вбудована конфігурація за замовчуванням імітує зовнішній вигляд і поведінку старого модуля Turtle, щоб зберегти найкращу сумісність із ним.

Якщо ви хочете використовувати іншу конфігурацію, яка краще відображає функції цього модуля або яка краще відповідає вашим потребам, напр. для використання в класі ви можете підготувати файл конфігурації `turtle.cfg`, який буде прочитано під час імпорту та змінено конфігурацію відповідно до його параметрів.

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

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

Коротке пояснення вибраних записів:

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

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

• shape може бути будь-якою вбудованою формою, наприклад: стрілка, черепаха тощо. Щоб дізнатися більше, спробуйте `help(shape)`.

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

• Якщо ви хочете відобразити черепаху в її стані, ви повинні використовувати `resizemode = auto`.

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

• Записи exampleturtle і examplescreen визначають імена цих об’єктів, як вони зустрічаються в рядках документації. Трансформація method-docstrings у function-docstrings видалить ці імена з docstrings.

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

У каталозі, де зберігається `turtle`, може бути файл `turtle.cfg` і додатковий у поточному робочому каталозі. Останній замінить налаштування першого.

Каталог `Lib/turtledemo` містить файл `turtle.cfg`. Ви можете вивчити його як приклад і побачити його вплив під час запуску демонстрацій (бажано не з програми перегляду демонстрацій).

`turtledemo` — Демонстраційні скрипти¶

Пакет `turtledemo` містить набір демонстраційних скриптів. Ці сценарії можна запускати та переглядати за допомогою демонстраційного засобу перегляду, що входить до комплекту, наступним чином:

```python -m turtledemo
```

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

```python -m turtledemo.bytedesign
```

Каталог пакунків `turtledemo` містить:

• Демо-переглядач `__main__.py`, який можна використовувати для перегляду вихідного коду сценаріїв і запуску їх одночасно.

• Кілька сценаріїв, що демонструють різні функції модуля `turtle`. Доступ до прикладів можна отримати через меню «Приклади». Їх також можна запускати автономно.

• Файл `turtle.cfg`, який служить прикладом того, як писати та використовувати такі файли.

Демонстраційні сценарії:

Ім’я

опис

особливості

bytedesign

складний класичний графічний візерунок черепахи

`tracer()`, затримка, `update()`

хаос

графіки динаміки Верхульста показують, що комп’ютерні обчислення можуть генерувати результати, іноді проти очікувань здорового глузду

світові координати

годинник

аналоговий годинник, який показує час вашого комп’ютера

черепахи як стрілки годинника, онтаймер

colormixer

дослід з r, g, b

`ondrag()`

ліс

3 дерева в ширину

рандомізація

фрактальні криві

Криві Гільберта і Коха

рекурсія

лінденмайер

етноматематика (індійські колами)

L-система

minimal_hanoi

Ханойські вежі

Прямокутні черепахи як ханойські диски (форма, розмір)

нім

грати в класичну гру nim з трьома купами палиць проти комп’ютера.

черепахи як німки, керовані подіями (миша, клавіатура)

фарба

супер мінімалістична програма для малювання

`onclick()`

мир

елементарний

черепаха: зовнішній вигляд і анімація

Пенроуз

аперіодичне укладання з повітряними зміями та дротиками

`stamp()`

планета_і_місяць

моделювання гравітаційної системи

складені форми, `Vec2D`

rosette

зразок зі статті у Вікіпедії про черепахову графіку

хоровод

танцюючі черепахи, що обертаються попарно в протилежному напрямку

складені форми, клон shapesize, нахил, get_shapepoly, оновлення

sorting_animate

наочна демонстрація різних методів сортування

просте вирівнювання, рандомізація

дерево

(графічне) дерево в ширину (з використанням генераторів)

`clone()`

два_полотна

простий дизайн

черепахи на двох полотнах

Інь Янь

ще один елементарний приклад

`circle()`

весело провести час!