Модуль Turtle в Python

Модуль turtle — это библиотека Python, которая помогает новичкам изучать программирование с помощью визуального рисования. В ней вы можете управлять виртуальной черепашкой и заставить её проползти на 100 шагов вперёд, повернуть на 90 градусов вправо и выполнить другие команды. Комбинирование таких простых действий позволяет создавать различные геометрические фигуры и сразу видеть результат на экране. Давайте подключим этот модуль и попробуем с ним поработать.

Содержание

• Установка и настройка Turtle
• Как управлять движением черепашки
• Расширенные функции Turtle
• Примеры применения
• Что дальше

Установка и настройка Turtle

Модуль turtle входит в стандартную библиотеку Python и относится к категории Program Frameworks. Такие модули задают базовую структуру кода с помощью набора готовых инструментов и правил. Например, в turtle нельзя просто нарисовать прямую линию. Для этого черепашке нужно доползти до начальной точки, повернуться в нужную сторону и только после этого проползти вперёд, оставляя за собой след.

Чтобы работать со стандартной библиотекой, сначала установите Python для своей операционной системы и выберите редактор кода. Подойдут PyCharm, Visual Studio Code, IDLE или любой другой редактор с графическим интерфейсом. Однако учтите, что модуль turtle не поддерживается на мобильных платформах и работает с ограничениями во многих онлайн-интерпретаторах вроде Jupyter Notebook или Replit.

Читайте также:

Топ-10 IDE для Python: редакторы для профи и новичков

После установки редактора создайте новый файл с расширением .py, задайте ему имя (например, drawing.py) и добавьте следующую строку:

import turtle

С этого момента модуль turtle подключён и готов к работе. Для проверки вы можете вставить в файл следующий код и запустить его, — если всё настроено правильно, черепашка нарисует звезду в отдельном окне:

import turtle

turtle.color('red', 'yellow')
turtle.begin_fill()
while True:
    turtle.forward(200)
    turtle.left(170)
    if abs(turtle.pos()) < 1:
        break
turtle.end_fill()
turtle.done()

Как управлять движением черепашки

Черепашку можно перемещать двумя способами: с помощью простых команд (вперёд, назад, поворот) или через указание координат (X, Y). В этом разделе мы кратко рассмотрим оба подхода, а затем перейдём к дополнительным функциям. Для более глубокого изучения советуем добавить в закладки официальную документацию Turtle graphics — в ней подробно описаны все команды и особенности работы с модулем turtle.

Начнём с основных команд, которыми вы будете пользоваться чаще всего:

• forward(длина) — двигает черепашку вперёд. Например, по команде forward (50) та продвинется на 50 пикселей и оставит за собой линию.
• backward(длина) — двигает назад на заданное расстояние.
• right(угол) — поворачивает вправо на указанный угол. Так, команда right(90) развернёт черепашку на 90 градусов по часовой стрелке.
• left(угол) — поворачивает влево на указанный угол.
• penup() — поднимает виртуальное перо, чтобы черепашка не оставляла след на экране.
• pendown() — опускает перо, чтобы снова появлялась линия.
• circle (радиус) — рисует окружность заданного радиуса.
• exitonclick() — оставляет окно с рисунком открытым до тех пор, пока вы не кликнете мышью.
• done() — завершает выполнение программы и оставляет окно с рисунком открытым.

Новички часто забывают добавить в конце программы команду done() или exitonclick(). Без них окно с рисунком быстро откроется и закроется сразу после выполнения кода, — вы не успеете ничего увидеть:

import turtle

# Cоздаём объект черепашки
t = turtle.Turtle()

# Рисуем линию длиной 100 пикселей
t.forward(100)

А теперь добавим в конце команду, и окно никуда не денется:

turtle.done()

Рабочее поле черепашки — это обычная координатная плоскость. По горизонтали идёт ось X (слева направо), по вертикали — ось Y (снизу вверх). В центре находится точка (0, 0), откуда черепашка начинает путь:

• goto(x, y) — перемещает в указанную точку с координатами (X, Y). Например, goto (100, 50) переместит вас в точку, где x = 100, y = 50.
• setx(x) — меняет координату X для перемещения по горизонтали.
• sety(y) — меняет координату Y для перемещения по вертикали.
• setheading(угол) — задаёт направление движения: 0 — вправо, 90 — вверх, 180 — влево, 270 — вниз.
• home() — возвращает черепашку в центр поля (0, 0) и устанавливает направление вправо.

Теперь объединим оба способа управления черепашкой. Сначала нарисуем квадрат с помощью базовых команд движения, а затем переместимся в новую позицию по координатам и нарисуем круг:

import turtle

# Cоздаём объект черепашки
t = turtle.Turtle()

# Рисуем квадрат
for _ in range(4):
    t.forward(100)
    t.left(90)

# Перемещаем черепашку для нового рисунка
t.penup()
t.goto(-150, 0)
t.pendown()

# Рисуем окружность радиусом 50 пикселей
t.circle(50)

turtle.done()

В результате вы должны увидеть две фигуры на одном поле:

Расширенные функции Turtle

До этого мы использовали только базовые возможности модуля turtle, которые заданы по умолчанию. Для создания более сложных узоров вы можете настраивать различные параметры отрисовки: цвет, размер, скорость и другие характеристики. Рассмотрим некоторые из них.

Цвет и заливка. Вы можете отдельно настраивать цвет пера (линии) и цвет заливки фигуры. Для этого можно использовать имена цветов на английском языке (red, blue, green) или их значения в HEX-формате — например, #FF0000 (красный), #00FF00 (зелёный), #0000FF (синий).

Обратите внимание: заливка работает только с замкнутыми фигурами: кругами, квадратами и многоугольниками. Она не применяется к незамкнутым линиям, спиралям и также не сработает, если между командами begin_fill() и end_fill() у вас появится разрыв в линии.

import turtle

t = turtle.Turtle()

t.pencolor("blue")      # Цвет линии
t.fillcolor("lightblue") # Цвет заливки

t.begin_fill()      # Начинаем заливку
t.circle(80)        
t.end_fill()        # Завершаем заливку

turtle.done()

Скорость, форма и отображение. Благодаря этим параметрам вы можете управлять тем, как черепашка рисует фигуры на экране:

• t.speed(n) задаёт скорость движения черепахи. Можно указать значения от 1 (очень медленно) до 10 (максимально быстро). При значении 0 рисунок появляется мгновенно, без анимации.
• t.shape(«turtle») меняет форму курсора. Вот доступные варианты: turtle (черепашка), arrow (стрелка), circle (круг), square (квадрат), triangle (треугольник) и classic (классический).
• Команда t.hideturtle() позволяет временно скрыть черепашку во время рисования, что ускоряет процесс. Затем вы можете использовать t.showturtle(), чтобы она снова появилась.
• Для сложных фигур можно отключить анимацию командой turtle.tracer(0), а после завершения всех действий вызвать turtle.update(). Это ещё один способ ускорить процесс отрисовки.

Поэкспериментируем с настройками и нарисуем две новые фигуры:

import turtle

t = turtle.Turtle()

# Меняем форму курсора со «стрелки» на «черепашку» 
t.shape("turtle")
t.speed(7)
t.color("green", "yellow")

t.begin_fill()
for _ in range(6):     # Рисуем правильный жёлтый шестиугольник
    t.forward(100)
    t.left(60)
t.end_fill()

t.penup()
t.goto(-150, 0)
t.pendown()

# Скрываем черепашку и создаём красный треугольник
t.hideturtle()
t.color("red", "orange")
t.begin_fill()
for _ in range(3):
    t.forward(80)
    t.left(120)
t.end_fill()
t.showturtle()

turtle.done()

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

• turtle.listen() — эта команда включает прослушивание событий от клавиатуры и мыши.
• turtle.onkeypress(func, key) — привязывает функцию к нажатию определённой клавиши.
• turtle.onclick(func) — позволяет обрабатывать щелчок мыши по самой черепашке.
• turtle.onscreenclick(func) — реагирует на щелчок мыши в любой точке экрана и передаёт координаты точки в функцию-обработчик.

Для закрепления изученных команд ниже мы создадим программу, которая позволит управлять черепахой с помощью клавиш-стрелок:

import turtle

# Создаём объект черепашки и настраиваем её внешний вид
t = turtle.Turtle()
t.shape("turtle")   
t.speed(0)          

# Настраиваем функции управления  
def move_forward():
    t.forward(30)  # Двигаемся вперёд на 30 пикселей

def move_backward():
    t.backward(30)  # Двигаемся назад на 30 пикселей

def turn_left():
    t.left(30)  # Поворачиваем влево на 30°

def turn_right():
    t.right(30)  # Поворачиваем вправо на 30°

def reset_position():
    t.penup()       
    t.home()        
    t.pendown()     

# Включаем прослушивание событий клавиатуры
turtle.listen()

# Назначаем действия на определённые клавиши:
turtle.onkeypress(move_forward, "Up")  # Стрелка вверх — вперёд
turtle.onkeypress(move_backward, "Down")  # Стрелка вниз — назад
turtle.onkeypress(turn_left, "Left")  # Стрелка влево — повернуть влево
turtle.onkeypress(turn_right, "Right")  # Стрелка вправо — повернуть вправо
turtle.onkeypress(reset_position, "space")  # Пробел — вернуться в центр

turtle.done()

Читайте также:

Функции в Python: исчерпывающий гайд

Работа с несколькими объектами. Вы можете создать несколько черепашек и управлять каждой из них по отдельности. Это пригодится при разработке анимаций или простых игр, где различные элементы (например, игрок или мяч) представлены отдельными объектами.

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

import turtle

# Создаём первую черепашку (красная)
t1 = turtle.Turtle()
t1.color("red")         
t1.shape("turtle")      

# Создаём вторую черепашку (синяя)
t2 = turtle.Turtle()
t2.color("blue")        
t2.shape("turtle")      

# Первая черепашка движется вправо на 100 пикселей
t1.forward(100)

# Вторая черепашка поворачивает вверх и двигается на 100 пикселей
t2.left(90)
t2.forward(100)

# Перемещаем первую черепашку в точку (-100, -100) без линии
t1.penup()              
t1.goto(-100, -100)     
t1.pendown()            

# Перемещаем вторую черепашку в точку (100, -100) без линии
t2.penup()
t2.goto(100, -100)
t2.pendown()

# Первая черепашка рисует круг радиусом 50 пикселей
t1.circle(50)

# Вторая черепашка поворачивает и движется ещё на 70 пикселей
t2.right(45)
t2.forward(70)

turtle.done()

Алгоритмические узоры и фракталы. С помощью циклов, функций и вложенных фигур вы можете визуализировать разные математические закономерности. Например, модуль random позволяет создать фрактал «папоротник Барнсли», который напоминает настоящее растение.

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

import turtle
import random

# Создаём функцию для построения фрактала 
def barnsley_fern(t, iterations):
    x, y = 0, 0  # Начальные координаты 
    for _ in range(iterations):
        r = random.random()  # Генерируем случайное число от 0 до 1
        # В зависимости от значения r выбираем одну из четырёх формул для новой точки
        if r < 0.01:
            x, y = 0, 0.16 * y                  # Стебель папоротника
        elif r < 0.86:
            x, y = 0.85 * x + 0.04 * y, -0.04 * x + 0.85 * y + 1.6   # Основная масса листьев
        elif r < 0.93:
            x, y = 0.2 * x - 0.26 * y, 0.23 * x + 0.22 * y + 1.6    # Левые листики
        else:
            x, y = -0.15 * x + 0.28 * y, 0.26 * x + 0.24 * y + 0.44 # Правые листики
        
        # Перемещаемся к новой точке 
        t.goto(x * 50, y * 50 - 200)
        t.dot(2, "yellow")  # Ставим точку диаметром 2 пикселя жёлтым цветом

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

t = turtle.Turtle()
t.speed(0)                
turtle.tracer(0)          
t.hideturtle()            
t.penup()                 

barnsley_fern(t, 50000)   # Используем 50 000 точек для красивого результата
turtle.update()           
turtle.done()

Читайте также:

Модуль random в Python

Пример применения

В предыдущих разделах вы познакомились с базовыми и расширенными возможностями модуля turtle: управлением, событиями, работой с несколькими объектами и случайными числами. Теперь попробуйте объединить эти возможности и реализовать игру «Поймай черепашку».

Вам нужно создать на игровом поле двух черепашек. Первая будет вашей — настройте для неё управление с помощью клавиш и мышки. Второй черепашкой пусть управляет компьютер — она должна случайно перемещаться по экрану и убегать от вас. Цель игры — догнать убегающую черепашку, вывести сообщение о победе и завершить программу.

import turtle
import random

FIELD_SIZE = 300          
JUMP_INTERVAL = 500       
CATCH_DISTANCE = 20       

# Создаём игровое окно 
screen = turtle.Screen()
screen.title("Поймай черепашку!")       
screen.bgcolor("#f0f0f0")                
screen.setup(width=700, height=700)      

# Создаём черепашку-игрока (красная) 
player = turtle.Turtle()
player.shape("turtle")                
player.color("red")                    
player.penup()                        
player.speed(0)                          
player.goto(0, -100)                    

# Создаём убегающую черепашку (синяя) 
runner = turtle.Turtle()
runner.shape("turtle")                
runner.color("blue")                     
runner.penup()
runner.speed(0)
runner.goto(0, 100)                      

game_active = True                       

# Добавляем управление клавишами с клавиатуры 
def move_forward():
    if game_active:
        player.forward(20)               
        check_catch()                  

def move_backward():
    if game_active:
        player.backward(20)             
        check_catch()

def turn_left():
    if game_active:
        player.left(30)                 

def turn_right():
    if game_active:
        player.right(30)                 

# Добавляем управление мышкой 
def go_to_click(x, y):
    if game_active:
        player.setheading(player.towards(x, y))  
        player.goto(x, y)                        
        check_catch()

# Настраиваем перемещение убегающей черепахи 
def runner_jump():
    if not game_active:
        return
    # Генерируем случайные координаты в пределах игрового поля
    new_x = random.randint(-FIELD_SIZE, FIELD_SIZE)
    new_y = random.randint(-FIELD_SIZE, FIELD_SIZE)
    runner.goto(new_x, new_y)           
    check_catch()                       
    # Планируем следующий прыжок через JUMP_INTERVAL миллисекунд
    screen.ontimer(runner_jump, JUMP_INTERVAL)

# Проверяем, получилось ли поймать убегающую черепаху 
def check_catch():
    # Сравниваем расстояние между черепахами
    if player.distance(runner) < CATCH_DISTANCE and game_active:
        end_game()

# Планируем действия после окончания игры 
def end_game():
    global game_active
    game_active = False
    runner.hideturtle()  # Скрываем обеих черепашек
    player.hideturtle()
    # Создаём черепашку для вывода сообщения
    message = turtle.Turtle()
    message.hideturtle()
    message.penup()
    message.goto(0, 0)
    message.color("green")
    message.write("Поймано! Победа!", align="center", font=("Arial", 24, "bold"))

# Привязываем управление к клавишам и мышке 
screen.listen()
screen.onkeypress(move_forward, "Up")      
screen.onkeypress(move_backward, "Down")   
screen.onkeypress(turn_left, "Left")       
screen.onkeypress(turn_right, "Right")     
screen.onclick(go_to_click)                

runner_jump()

turtle.done()

Что дальше

Модуль turtle — отличный способ познакомиться с основами программирования на Python. После его освоения вы будете готовы перейти к более сложным инструментам и попробовать следующие:

• Pygame — библиотека для создания 2D-игр на Python. Она позволяет работать с графикой, добавлять звуковые эффекты, а также обрабатывать действия игрока — нажатия клавиш, движения мыши и прочее. Например, вы можете написать на Pygame игру «Змейка».
• Tkinter — стандартная библиотека Python для создания графического интерфейса. С её помощью можно создавать окна, кнопки, текстовые поля и другие элементы интерфейса. Например, на Tkinter легко реализовать калькулятор индекса массы тела.
• Matplotlib — библиотека для построения графиков, диаграмм и визуализации данных. Например, вы можете создать столбчатую диаграмму с накоплением и отследить, как со временем изменялось соотношение Android- и iOS-устройств на рынке смартфонов.