Основы модуля turtle в Python: рисуем с черепашкой

Рассказываем, как работает модуль turtle для рисования графики, как его установить и использовать в своих проектах. В статье — основные команды, примеры кода для рисования разных фигур и работы с их стилем.

Что такое модуль turtle в Python

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

У этой «черепашки» есть положение на плоскости и направление «взгляда». Когда она делает шаг, на экране появляется отрезок. Либо не появляется, если отключить рисование. Благодаря тому, что модель интуитивно понятна и можно сразу увидеть результат каждой строки, новичкам легче ее освоить и сосредоточиться на логике.

Установка и импорт turtle

Модуль turtle входит в стандартную библиотеку Python, поэтому устанавливать его через pip не нужно. Достаточно поставить сам Python с поддержкой Tkinter, потому что графическое окно «черепашки» работает поверх Tk.

• Чтобы установить Python, прочитайте руководство. 
• В версиях Python старше Python 2 все необходимое для работы с Tk уже идет в комплекте с основным пакетом установки, поэтому его не нужно специально устанавливать. 

Однако в некоторых сборках для Linux его нередко выносят в отдельный системный пакет. Если по какой-то причине Tk отсутствует в пакете, то следуйте инструкции на официальном сайте.

Также вы можете попробовать онлайн-редактор кода с встроенным компилятором на сайте trinket.io.

В примерах далее мы будем использовать среду IDLE, которая поставляется вместе с установочным пакетом Python.

Как управлять черепашкой

Чтобы проверить, что tkinter работает, создадим файл с расширением .py. Импортируем библиотеки и создадим черепашку t, которая пойдет по заданному маршруту.

import tkinter
import turtle as t

t.forward(50)
t.left(90)
t.forward(50)
t.done()

Завершаем движение черепашки функцией done(). Результат должен выглядеть таким образом:

По умолчанию установлен стандартный режим (standard). Это значит, что черепашка стартует из центра окна в точке (0, 0), смотрит вправо и у нее опущено перо, то есть она сразу рисует при движении.

Второй режим, который поддерживает turtle, — это logo, у которого старт также начинается в центре и перо опущено, но черепашка при этом смотрит вверх.

Основные различия заключаются в трех показателях:

• Начальное направление

standard — черепашка изначально смотрит вправо (0°).

logo — черепашка изначально смотрит вверх (0°).

• Направление роста углов

standard — углы увеличиваются против часовой стрелки.

logo — углы увеличиваются по часовой стрелке.

• Влияние на heading()

heading() — это функция, которая возвращает текущий угол поворота черепашки (направление, куда она «смотрит») в градусах.

В standard угол 90° — это вверх, в logo — вправо.

Если вы пишете код, использующий только left() и right(), разницы между режимами почти нет, так как эти команды работают визуально одинаково.

Разница заметна, когда вы используете установку угла setheading() или проверяете угол через heading(), так как углы интерпретируются по-разному.

Режим world

Существует также и третий режим — world (режим «мировых координат»). Тогда мы сами задаем, как прямоугольник действительных координат проецируется на окно. Для этого используют setworldcoordinates(llx, lly, urx, ury), где ll и ur — это lower left (нижний левый) и upper right (верхний правый) соответственно.

Углы в world ведут себя как в standard: 0° — вправо, рост угла — против часовой. Начало координат и масштаб будут такими, какими вы их зададите. Например, можно сделать «математическую» систему с левым нижним углом (0, 0) и правым верхним (10, 10).

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

Рисование фигур

Начнем с фигур из отрезков. Тут важно сразу обозначить основное правило:

Наружный угол поворота черепашки равен 360 / n, где n — число сторон фигуры.

Что это значит?

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

Для правильного n-угольника:

• Черепашка рисует n сторон, поворачивая на одинаковый угол после каждой стороны.
• Сумма всех внешних углов поворота равна 360°, так как это полный круг.
• Поскольку углы равны, каждый внешний угол = 360° / n.

Примеры:

Для треугольника (n = 3): 360° / 3 = 120°. Черепашка поворачивает на 120° после каждой стороны. 

Для квадрата (n = 4): 360° / 4 = 90°.

Координаты и позиция

Указание координат нужно, чтобы размещать фигуры в точной точке поля. Экран в turtle — это плоскость с центром в начале координат (0, 0), ось X направлена вправо, ось Y — вверх.

• Команда goto(x, y) перемещает черепашку в абсолютную точку. Если перо опущено, на пути появится линия; если поднято, следа не будет. Альтернативы goto — setpos и setposition. Все три команды выполняют одно и то же. 
• Текущие координаты можно узнать через position() или короткое pos(), а по каждой из осей — через xcor() и ycor(). Переходы не зависят от того, куда «смотрит» черепашка, они просто меняют ее местоположение.
• Для возврата в центр есть home().

Квадрат и равносторонний треугольник

Нарисуем с помощью черепашки квадрат и равносторонний треугольник. Чтобы слегка «замедлить» черепашку для наглядности, используем функцию speed(). В зависимости от переданного значения скорость будет меняться:

0 — без анимации, рисует мгновенно.

10 — очень быстро.

6 — по умолчанию.

3 — медленно.

1 — самое медленное.

Выберем скорость 3, чтобы легко отследить движения черепашки.

import turtle as t

t.speed(3)

# Квадрат со стороной 80
# Тут цикл for повторяется 4 раза для каждой из сторон квадрата
for _ in range(4):
    t.forward(80)
    t.left(90)

# Тут мы поднимаем перо и отключаем рисование, чтобы переместиться в точку с координатами (150, 0) для рисования треугольника. Затем опускаем перо
t.penup()
t.goto(150, 0)
t.pendown()

# Равносторонний треугольник со стороной 100
for _ in range(3):
    t.forward(100)
    t.left(120)

t.done()

Получим такой результат:

Многоугольник

Чтобы не дублировать код для каждого многоугольника, рекомендуем «упаковать» логику в отдельную вспомогательную функцию polygon(n, side), где n — количество сторон фигуры (шагов), а side — длина стороны (шага).

Внутри функции черепашка делает n одинаковых шагов и на каждой вершине поворачивает на угол 360 / n. Для наглядности снова используем speed(3), чтобы видеть процесс рисования с небольшой паузой.

import turtle as t

def polygon(n, side):
    # На каждой вершине поворачиваем на 360/n градусов
    turn = 360 / n
    for _ in range(n):
        t.forward(side)
        t.left(turn)

t.speed(3)

# Пятиугольник со стороной 90
polygon(5, 90)

# Перемещаемся без рисования к новой стартовой точке
t.penup()
t.goto(180, 0)
t.pendown()

# Восьмиугольник со стороной 50
polygon(8, 50)

t.done()

Получим два многоугольника:

Пятиконечная звезда

Звезда получается, если идти по вершинам правильного пятиугольника не к соседней вершине, а перескакивая одну. То есть каждый раз мы соединяем текущую вершину со следующей через одну. Для такого шага нужен постоянный поворот на угол 360 * 2/5 = 144°. 

Пять одинаковых поворотов по 144° дают два полных оборота, поэтому контур замыкается ровно в звезду.

import turtle as t

t.speed(3)

for _ in range(5):
    t.forward(120)
    t.right(144)
t.end_fill()

t.done()

Получаем такой результат:

Фигуры с разными сторонами

Когда нужна фигура, где каждая сторона своей длины, не вычисляем 360 / n, а описываем маршрут шагами: пройти d пикселей, затем повернуть влево или вправо на заданный угол, и так — для каждой стороны.

Напишем универсальную функцию draw_path(steps, start=None) для рисования таких фигур, где: 

• steps — список с инструкциями: длина шага, направление поворота (L — влево, R — вправо) и угол поворота.
• start — начальная точка (координаты x, y), если нужно начать не с (0, 0). По умолчанию указываем None.

import turtle as t

def draw_path(steps, start=None):

Проверяем, задано ли значение start.

if start is not None:

Поднимаем перо, перемещаем черепашку в точку start (распаковываем кортеж), опускаем перо.

t.penup(); t.goto(*start); t.pendown()

Цикл по списку steps: распаковываем каждый кортеж на длину, направление поворота и угол.

for length, turn, angle in steps:

Двигаем черепашку вперед на указанную длину.

t.forward(length) 

Проверяем, равно ли направление поворота L (влево, без учета регистра).

if turn.upper() == 'L':

Поворачиваем черепашку влево на указанный угол.

t.left(angle)

Если направление не L, то считаем, что это R (вправо).

else:

Поворачиваем черепашку вправо на указанный угол

t.right(angle).

t.speed(3)

Теперь создаем фигуры:

Прямоугольник 160×90

Создаем список rect с кортежами для рисования прямоугольника.

rect = [

Шаг 160 пикселей, поворот влево на 90°

(160, 'L', 90),

Шаг 90 пикселей, поворот влево на 90°

(90, 'L', 90),

Шаг 160 пикселей, поворот влево на 90°

(160, 'L', 90),

Шаг 90 пикселей, поворот влево на 90°

(90, 'L', 90),

]

Вызываем функцию draw_path для рисования прямоугольника по списку rect.

draw_path(rect) 

Рядом добавим другую фигуру (меняем шаги и стартовую точку).

Поднимаем перо, перемещаем черепашку в точку (220, 0), опускаем перо:

t.penup(); t.goto(220, 0); t.pendown()

Создаем список trapezoid с кортежами для рисования трапеции.

trapezoid = [

Шаг 140 пикселей, поворот влево на 60°

(140, 'L', 60),

Шаг 60 пикселей, поворот влево на 120°

(60, 'L', 120),

Шаг 140 пикселей, поворот влево на 60°

(140, 'L', 60),

Шаг 60 пикселей, поворот влево на 120°

(60, 'L', 120),

]

Вызываем функцию draw_path для рисования трапеции по списку trapezoid.

draw_path(trapezoid)
t.done()

Получаем результат:

Окружности и дуги

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

• Центр окружности находится на расстоянии |r| слева от текущего курса. 
• Если радиус отрицательный, центр оказывается справа и дуга пойдет по часовой. 

Параметр extent задает угол дуги в градусах. Если его не указать, то получится полный круг, если extent = 180, получится полукруг, при любом другом значении — дуга. 

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

import turtle as t

t.speed(3)

# Полный круг радиуса 60 (против часовой)
t.circle(60)

# Полукруг: ограничиваем дугу 180 градусами
t.penup(); t.goto(140, 0); t.pendown()
t.circle(60, extent=180)

# Дуга по часовой: берем отрицательный радиус
t.penup(); t.goto(280, 0); t.pendown()
t.circle(-60, extent=120)

t.done()

Получаем:

Работа с цветами и стилем

Цвет линий задаем через color() или точечно — через pencolor().

Толщину линий — через pensize(). 

Цвет заливки — fillcolor(). Заливка срабатывает между begin_fill() и end_fill(), то есть все, что вы нарисуете между их вызовами, воспринимается как контур фигуры, а ее внутренняя область будет закрашена.

Нарисуем произвольную фигуру с такими параметрами: 

• обводка #1f6f8b
• заливка #ffd166
• толщина линии 4
• скорость 3
• вершины (-140, -40) → (-20, 60) → (100, 20) → (160, -80) → (20, -120) → в начало

import turtle as t

# Параметры фигуры
points = [(-140, -40), (-20, 60), (100, 20), (160, -80), (20, -120)]
stroke_color = "#1f6f8b"
fill_color = "#ffd166"
line_width = 4
speed = 3

t.speed(speed)
t.pensize(line_width)
# Цвет линии
t.color(stroke_color)
# Цвет заливки
t.fillcolor(fill_color)

# Переходим к первой вершине без следа
t.penup()
t.goto(points[0])
t.pendown()

# Рисуем замкнутую ломаную с заливкой
t.begin_fill()
for x, y in points[1:]:
    t.goto(x, y)

# Замыкаем контур в начальной точке
t.goto(points[0])
t.end_fill()

t.done()

Получим такой результат:

Полезные фишки 

• Можно задать обводку и заливку одной командой t.color(stroke_color, fill_color). 
• Есть поддержка имен цветов («gold», «tomato») и шестнадцатеричные коды #RRGGBB. 
• Если хотите работать с RGB-кортежами, включите режим t.colormode(255) и передавайте (r, g, b) с параметрами 0–255.

Отмена действий

Иногда нужно стереть рисунок и начать «с чистого листа». В turtle для этого есть три команды:

• t.clear() удаляет следы конкретной черепашки (t), не меняя ее положение. Позиция, курс, толщина и цвет пера, скорость — все остается как было. Рисунки других черепашек это не затрагивает.
• t.reset() удаляет следы конкретной черепашки и возвращает ее к стартовым настройкам: центр (0, 0), курс 0°, перо опущено, базовые цвета и размеры. Удобно, когда нужно начать рисовать заново той же черепашкой.
• screen.clearscreen() очищает все окно: стирает все линии и сбрасывает состояние всех черепашек и экрана. Иначе говоря, делает общий «сброс сцены».

Формы и внешний вид черепашки

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

• shape(name) меняет «курсор»-черепашку. 

Доступные встроенные формы: arrow, turtle, circle, square, triangle, classic (по умолчанию). 

• hideturtle() и showturtle() (коротко ht() и st()) прячет или показывает черепашку. Проверить видимость можно с помощью isvisible().

Например:

Параметры черепашек:

1 — make_turtle(«turtle», «#1f6f8b», «#bde0fe», stretch=(1.4, 2.0), pos=(-220, 80), heading=0)

2 — make_turtle(«circle», «#d1495b», «#ffd166», stretch=(1.3, 1.3), pos=(-70,  80), heading=45)

3 — make_turtle(«triangle», «#2a9d8f», «#e9c46a», stretch=(1.6, 1.6), pos=( 80,  80), heading=-30)

4 — make_turtle(«square», «#264653», «», stretch=(1.2, 1.2), pos=(230,  80), heading=90)

Несколько черепашек

Если нужно несколько черепашек, используйте объектный стиль: создайте отдельные экземпляры класса turtle.Turtle(). У каждой черепашки будут свои цвет, толщина линии, скорость, заливка, позиция и курс. Все они будут рисовать в одном окне (Screen), но состояние у каждой независимое. 

Функции верхнего уровня управляют только «черепахой по умолчанию». То есть, например, t.forward() будет двигать «дефолтную» черепашку, а a.forward(), если a = t.Turtle(), конкретную черепаху a.

Пример с двумя черепашками

import turtle as tr

screen = tr.Screen()
# Устанавливаем название окна, в котором запустится программа
screen.title("Две черепахи")

# Создаем две независимые черепахи
a = tr.Turtle()
b = tr.Turtle()

# Стили
a.color("#1f6f8b")
a.pensize(3)
a.speed(3)
a.shape("turtle")

b.color("#d1495b", "#ffd166")
b.pensize(2)
b.speed(4)
b.shape("turtle")

# A рисует квадрат слева
a.penup(); a.goto(-200, -40); a.setheading(0); a.pendown()
for _ in range(4):
    a.forward(120); a.left(90)

# B рисует произвольный пятиугольник справа с заливкой
pts = [(80, 20), (180, 80), (220, -10), (160, -90), (60, -40)]
b.penup(); b.goto(pts[0]); b.pendown()
b.begin_fill()
for x, y in pts[1:]:
    b.goto(x, y)
# Замыкаем контур b.goto(pts[0])
b.end_fill()

tr.done()

Получаем результат:

Окно и экран

Настройку окна можно делать через объект Screen. Чтобы его получить, вводим команду screen = turtle.Screen(). Через него настраивают фон, размер «холста» и заголовок окна.

Основные настройки

1. Цвет фона окна

screen.bgcolor(color)

Задает цвет фона окна.

Варианты цвета: beige, red, blue.

Код в формате HEX: «#ffe8a1» (светло-желтый).

RGB-кортеж: (255, 225, 161) — но сначала нужно включить режим screen.colormode(255) для работы с RGB.

Пример: 

screen = turtle.Screen()
screen.bgcolor("lightblue")

2. Размер холста

screen.screensize(width, height)

Задает размер области рисования (холста) в пикселях. Если холст больше окна, появляются полосы прокрутки.

Пример:

# Холст 1000 на 800 пикселей screen.screensize(1000, 800)

Нужно учитывать, что это не размер окна, а размер области внутри него.

3. Заголовок окна

screen.title(text)

Задает текст в верхней части окна.

Пример: 

screen.title("Черепашка")

Как управлять окном

Есть команды, которые контролируют, как окно работает и закрывается:

1. Держать окно открытым

turtle.done() или screen.mainloop()

Запускает главный цикл Tkinter, чтобы окно не закрылось сразу после рисования. Обычно ставится в конце кода.

2. Закрытие окна по клику

screen.exitonclick()

Окно остается открытым, пока не кликнуть мышью. После клика окно закрывается.

Внутри exitonclick() автоматически вызывает mainloop() и затем bye() (закрытие окна).

Интерактивные функции

Черепашкой также можно управлять с клавиатуры с помощью метода onkeypress().

Метод onkeypress(func, key)

Привязывает функцию func к клавише key. Когда нажимаете клавишу, вызывается указанная функция.

Примеры клавиш: Up (стрелка вверх), Down, Left, Right, space (пробел), a–z, Escape.

Пример:

screen.onkeypress(move_forward, «Up») — нажатие стрелки вверх вызывает функцию move_forward.

Метод screen.listen()

Включает режим, в котором окно turtle начинает «слушать» нажатия клавиш. Без этого клавиши не работают.

Отвязка клавиши

Команда screen.onkeypress(None, «space») отключает обработчик для клавиши space, чтобы она больше не вызывала функцию.

Напишем небольшую рисовалку

Создадим интерактивную программу для управления черепашкой с клавиатуры:

• Стрелки двигают черепашку вперед, назад, влево, вправо.
• Space поднимает или опускает перо (вкл/выкл рисование).
• [ и ] уменьшают/увеличивают толщину линии.
• Z отменяет последнее действие (шаг назад).

Для реализации выберем режим logo, чтобы черепашка смотрела вверх на старте.

Пример кода:

import turtle as t

t.mode("logo")

screen = t.Screen()
screen.title("Интерактивная рисовалка (режим logo)")
t.shape("turtle")

# Устанавливаем быструю реакцию на клавиши
t.speed(0)
t.pensize(3)

# Длина шага
STEP = 15

# Управление
def move_forward():
    t.forward(STEP)

def move_back():
    t.backward(STEP)

def strafe_left():
    # «Скольжение» влево без изменения итоговой ориентации
    t.left(90); t.forward(STEP); t.right(90)

def strafe_right():
    t.right(90); t.forward(STEP); t.left(90)

def turn_left():
    t.left(TURN)

def turn_right():
    t.right(TURN)

def toggle_pen():
    if t.isdown(): t.penup()
    else: t.pendown()

def thinner():
    t.pensize(max(1, t.pensize() - 1))

def thicker():
    t.pensize(min(20, t.pensize() + 1))

def next_color():
    pi[0] = (pi[0] + 1) % len(palette)
    t.pencolor(palette[pi[0]])

def undo_step():
    t.undo()

# Привязываем (биндим) клавиши
screen.listen()
# Стрелки -- движение (вперед/назад и «влево/вправо»)
screen.onkeypress(move_forward, "Up")
screen.onkeypress(move_back, "Down")
screen.onkeypress(strafe_left, "Left")
screen.onkeypress(strafe_right, "Right")
# Инструменты
screen.onkeypress(toggle_pen, "space")
screen.onkeypress(thicker, "]")
screen.onkeypress(thinner, "[")
screen.onkeypress(undo_step, "z")

t.done()

Результат: