Черепашья графика с использованием модуля Turtle в Python

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

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

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

Идею черепашьей графики ввел Seymour Papert в рамках его работы по конструктивизму и образованию. Паперт совместно с Лого (Logo) — языком программирования, разработанным в MIT в 1960-х годах, внедрил этот метод для использования в образовательных целях. Черепашья графика позволяет программистам «управлять» черепахой, задавая ей команды для перемещения, поворота и рисования на экране.

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

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

Как черепаха может двигаться и рисовать на экране?

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

1. forward(n): Черепаха перемещается вперед на расстояние n пикселей, рисуя линию.
2. backward(n): Черепаха перемещается назад на расстояние n пикселей, также рисуя линию.
3. left(angle): Черепаха поворачивается влево на угол angle градусов.
4. right(angle): Черепаха поворачивается вправо на угол angle градусов.
5. penup(): Перо черепахи поднимается, и она может перемещаться без рисования.
6. pendown(): Перо черепахи опускается, и она снова начинает рисовать.
7. goto(x, y): Черепаха перемещается в указанную точку (x, y), рисуя линию по пути.
8. setheading(angle): Устанавливает направление черепахи на заданный угол.
9. color(c): Устанавливает цвет линии и заливки, где c может быть названием цвета или RGB-кортежем.
10. begin_fill() и end_fill(): Начинают и заканчивают заливку фигур, чтобы они были закрашены цветом.

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

Модуль Turtle в Python. Работаем с черепашьей графикой.

Как подключить модуль Turtle?

Для использования модуля Turtle в Python, вам нужно выполнить следующие шаги:

1. Импортировать модуль Turtle: В начале вашего кода добавьте строку импорта для модуля Turtle:

   import turtle
   

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

2. Создать черепаху: После импорта модуля Turtle, создайте объект черепахи:

   t = turtle.Turtle()
   

   Этот код создает черепаху с именем «t». Теперь вы можете использовать этот объект для управления движением и рисованием.

3. Опционально: Настроить характеристики черепахи (необязательно): Вы можете настроить различные параметры черепахи, такие как скорость, цвет пера, толщина линии и др. Например:

   t.speed(2)  # Установить скорость черепахи (1 - медленно, 10 - быстро)
   t.pensize(2)  # Установить толщину линии
   t.color("blue")  # Установить цвет линии
   

   Теперь ваша программа готова к использованию черепахи для рисования на экране.

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

Начало рисования

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

• Начальные координаты: По умолчанию, начальные координаты для черепаши на холсте (0, 0) находятся в центре холста. Таким образом, черепаха начинает свои движения и рисование именно из центра.
• Начальное направление: Начальное направление черепахи по умолчанию направлено вправо (вдоль оси x). Таким образом, при начальных координатах (0, 0), черепаха будет смотреть вправо.
• Координаты:
  • Ось X направлена вправо от центра холста.
  • Ось Y направлена вверх от центра холста.

  Положительные значения по осям X и Y уходят вправо и вверх соответственно, а отрицательные значения — влево и вниз.

Эти начальные параметры можно изменять с использованием различных команд, таких как goto(x, y) для перемещения черепахи в определенные координаты или setheading(angle) для установки начального направления.

Пример:

import turtle

t = turtle.Turtle()

# Перемещение черепахи в точку (100, 50)
t.goto(100, 50)

# Установка начального направления на 45 градусов
t.setheading(45)

# Рисование линии в новом направлении
t.forward(100)

turtle.done()

Подготовка к рисованию. Обзор методов.

1. shape(«форма»):
   • Определяет внешний вид черепахи. Форма может быть «turtle» (по умолчанию), «arrow», «circle», «square», или «triangle». Например:

     t.shape("turtle")
     

2. penup() и pendown():
   • penup() поднимает перо черепахи, так что она может перемещаться без рисования.
   • pendown() опускает перо, чтобы черепаха снова начала рисовать. Пример:

     t.penup()
     t.goto(50, 50)
     t.pendown()
     

3. pensize(width):
   • Устанавливает толщину линии, которую рисует черепаха. Принимает аргумент — ширину линии в пикселях. Пример:

     t.pensize(3)
     

4. color(«цвет линии»):
   • Устанавливает цвет линии черепахи. Цвет может быть задан как строка (например, «red») или RGB-кортеж. Пример:

     t.color("blue")
     

5. pencolor(«цвет линии»):
   • Альтернативный способ установки цвета линии черепахи. Пример:

     t.pencolor("green")
     

6. speed(speed):
   • Устанавливает скорость черепахи. Аргумент speed может принимать значения от 1 (медленно) до 10 (быстро) . 0 или строку «fastest» для максимальной скорости. Пример:

     t.speed(3)
     

Рисование с помощью turtle

Обзор методов для рисования

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

1. forward(distance) и backward(distance):
   • forward(distance) перемещает черепаху вперед на указанное расстояние (в пикселях), рисуя линию при этом.
   • backward(distance) перемещает черепаху назад на указанное расстояние, также рисуя линию.

     t.forward(100)  # Перемещение вперед на 100 пикселей
     t.backward(50)  # Перемещение назад на 50 пикселей
     

2. left(angle) и right(angle):
   • left(angle) поворачивает черепаху на указанный угол влево.
   • right(angle) поворачивает черепаху на указанный угол вправо.

     t.left(90)  # Поворот влево на 90 градусов
     t.right(45)  # Поворот вправо на 45 градусов
     

3. goto(x, y):
   • goto(x, y) перемещает черепаху в точку с координатами (x, y), рисуя линию при этом.

     t.goto(100, 50)  # Перемещение в точку (100, 50)
     

4. setheading(angle):
   • setheading(angle) устанавливает направление черепахи на указанный угол.

     t.setheading(45)  # Установка направления на 45 градусов
     

   • В методе setheading(angle), направление черепахи задается относительно направления вправо (вдоль положительной оси X). Таким образом, угол 0 градусов соответствует направлению вправо.Положительные углы в setheading() поворачивают черепаху против часовой стрелки, а отрицательные — по часовой стрелке. Например:
     • setheading(90): Поворот вверх на 90 градусов.
     • setheading(-45): Поворот вниз на 45 градусов.

     Таким образом, положительные углы увеличиваются в направлении против часовой стрелки от оси X, а отрицательные — в направлении по часовой стрелке.

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

Рисование простых фигур

1. Квадрат

   import turtle
   
   t = turtle.Turtle()
   
   # Рисование квадрата
   for _ in range(4):
       t.forward(100)  # Длина стороны
       t.left(90)      # Угол поворота
   
   turtle.done()
   

2. Круг

   import turtle
   
   t = turtle.Turtle()
   
   # Рисование круга
   t.circle(100)  # Радиус круга
   
   turtle.done()
   

3. Треугольник

   import turtle
   
   t = turtle.Turtle()
   
   # Рисование треугольника
   for _ in range(3):
       t.forward(100)  # Длина стороны
       t.left(120)      # Угол поворота
   
   turtle.done()
   

4. Прямоугольник

   
   import turtle
   
   t = turtle.Turtle()
   
   t.speed(1)
   
   
   # Рисование прямоугольника
   for _ in range(2):
       t.forward(150)  # Длина 1 стороны
       t.left(90)      # Поворот на 90 градусов
       t.forward(50)  # Длина 2 стороны
       t.left(90)      # Поворот на 90 градусов
   turtle.done()
   

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

Экспериментируйте с длинами сторон, углами поворота и комбинациями команд, чтобы создавать разнообразные геометрические фигуры. Используйте методы настройки, такие как pensize(), color(), и pencolor(), чтобы добавить креативные элементы в ваши рисунки.

Цвета, заливка, фон

Модуль Turtle предоставляет несколько методов для управления цветами, заливкой фигур и управлением холстом. Давайте рассмотрим основные методы в этом контексте:

1. color(color) и pencolor(color):
   • color(color) устанавливает цвет линии и заливки (если применяется) в указанный цвет.
   • pencolor(color) устанавливает только цвет линии.

   Цвет можно указать либо строкой с названием цвета (например, «red», «blue»), либо HTML-цветом (например, '#FF0000' для красного).

   t.color("green")
   t.pencolor("blue")
   

2. begin_fill() и end_fill():
   • begin_fill() начинает заливку фигуры цветом, установленным методом color().
   • end_fill() завершает заливку фигуры.

     t.begin_fill()
     # Код для рисования фигуры
     t.end_fill()
     

3. bgcolor(color):
   • bgcolor(color) устанавливает цвет фона холста.

     turtle.bgcolor("lightgray")
     

4. screensize(width, height):
   • screensize(width, height) устанавливает размер холста

     turtle.screensize(800, 600)
     

5. title(title):
   • title(title) устанавливает заголовок окна холста.

     turtle.title("Мой Холст")
     

      

Как установить размер окна с привязкой к размеру экрана устройства?

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

import turtle

# Получение размеров экрана
screen = turtle.Screen()
screen_width = screen.window_width()
screen_height = screen.window_height()

# Установка размеров окна с отступом от краев экрана
desired_width = int(screen_width * 0.8)  # Например, 80% от ширины экрана
desired_height = int(screen_height * 0.8)  # Например, 80% от высоты экрана
turtle.screensize(desired_width, desired_height)

# Остальной код для рисования или других действий

turtle.done()

В этом примере screensize() используется для установки размеров холста, и эти размеры вычисляются с учетом процентного отношения от размеров экрана (screen.window_width() и screen.window_height()).

Установка фонового изображения

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

Поддерживаются различные форматы изображений, такие как GIF, PGM, PPM, PNG, BMP, и XBM.

Пример установки фонового изображения:

import turtle

# Установка фонового изображения
turtle.bgpic("background.png")

# Остальной код для рисования или других действий

turtle.done()

Очистка и сброс рисования

Метод clearscreen() в модуле Turtle используется для очистки холста (экрана), удаляя все нарисованные ранее объекты, возвращая черепаху в начальное положение и сбрасывая все текущие параметры.

Пример использования clearscreen():

import turtle

t = turtle.Turtle()

# Некоторые команды для рисования
t.forward(100)
t.right(90)
t.circle(50)

# Очистка холста
turtle.clearscreen()

# Новые команды для рисования (после clearscreen())
t.forward(150)
t.left(120)
t.backward(80)

turtle.done()

В этом примере после выполнения ряда команд для рисования, clearscreen() вызывается для очистки холста. После очистки вы можете использовать новые команды для рисования на чистом холсте.

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

Метод clearscreen() также может принимать аргументы, такие как bg и bgpic, чтобы установить новый фоновый цвет или изображение после очистки холста.

Как задать произвольный цвет кисти или заливки.

turtle модуле, методы color() и pencolor() ожидают строки, представляющие цвет. Чтобы установить цвет черепахи, используйте строки, представляющие имя цвета или его HTML-код. Если вы хотите использовать RGB, можно воспользоваться сторонней библиотекой, такой как colormath или colorsys.

Пример с использованием colormath:

from turtle import Turtle
from colormath.color_objects import RGBColor

t = Turtle()

# Задаем цвет с использованием RGB
rgb_color = RGBColor(255, 0, 0)
hex_color = rgb_color.get_rgb_hex()
t.color(hex_color)

t.forward(100)

# Второй цвет
rgb_color = RGBColor(0, 255, 0)
hex_color = rgb_color.get_rgb_hex()
t.pencolor(hex_color)

t.forward(100)

t.getscreen().exitonclick()

Прежде чем использовать код с colormath, убедитесь, что у вас установлена эта библиотека:

pip install colormath

В модуле Turtle в Python также можно задавать цвета в виде строк, представляющих HTML-код цвета. Вот пример:

import turtle

t = turtle.Turtle()

# Задаем цвет с использованием HTML-кода
t.color('#FF00FF')  # Магента

t.forward(100)

# Второй цвет
t.pencolor('#00FFFF')  # Цвет морской волны

t.forward(100)

turtle.done()

В этом примере '#FF00FF' представляет фиолетовый, а '#00FFFF' представляет цвет морской волны.

Вывод текста. Метод write()

Метод write в модуле Turtle используется для написания текста на экране. Этот метод позволяет черепахе оставлять текстовые сообщения на холсте.

Вот пример использования метода write:

import turtle

# Настройка черепахи
my_turtle = turtle.Turtle()
my_turtle.speed(1)

# Написание текста на экране
my_turtle.write("Привет, мир!", align="center", font=("Arial", 16, "normal"))

turtle.done()

В этом примере:

• "Привет, мир!" — текст, который будет написан на экране.
• align="center" — выравнивание текста. В данном случае, текст будет выровнен по центру.
• font=("Arial", 16, "normal") — установка шрифта. Здесь используется шрифт Arial размером 16 пикселей и стилем «normal».

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

score = 42

my_turtle.write(f"Очки: {score}", align="center", font=("Arial", 16, "normal"))

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

Рисование сложных узоров в модуле turtle

1. Использование цикла for для создания узоров:
   • Циклы могут быть мощным инструментом при создании узоров. Например, вы можете использовать циклы для повторения определенных геометрических форм и их комбинаций.

   Пример:

   import turtle
   
   t = turtle.Turtle()
   
   for _ in range(36):
       t.forward(100)
       t.right(170)
   
   turtle.done()
   

2. Использование цикла while для создания узоров:
   • Этот код использует бесконечный цикл (while True), чтобы черепаха рисовала узор.
   • forward(200): Черепаха двигается вперед на 400 пикселей, рисуя линию.
   • left(170): Черепаха поворачивает влево на угол 175 градусов. Этот угол был выбран для создания интересного узора.
   • if abs(pos()) < 1:: pos() возвращает текущие координаты черепахи. abs(pos()) вычисляет расстояние от центра холста (0, 0) до текущего положения черепахи. Если это расстояние меньше 1 пикселя, это означает, что черепаха вернулась близко к центру.
   • break: Если условие в if выполняется (черепаха близка к центру), то цикл завершается с помощью команды break, и программа выходит из бесконечного цикла.
   • Таким образом, код создает узор, перемещая черепаху вперед, поворачивая ее на угол, и проверяя, вернулась ли черепаха близко к центру холста. Как только это происходит, программа завершает выполнение, и узор завершается.

     import turtle
     
     t = turtle.Turtle()
     turtle.bgcolor('black')
     
     turtle.title("Мой Холст")
     t.speed(8)
     t.color('yellow','blue')
     t.begin_fill()
     while True:
         t.forward(400)
         t.left(175)
         if abs(t.pos()) < 1:
             break
     t.end_fill()
     t.pensize(2)
     t.up()
     t.goto(200,-200)
     t.pencolor('green')
     t.down()
     t.circle(210)
     t.up()
     t.goto(200,-210)
     t.down()
     t.pencolor('red')
     t.circle(220)
     turtle.done()

3. Использование функций для абстракции и повторного использования:
   • Функции позволяют создавать более структурированный код, который можно легко модифицировать и повторно использовать для разных узоров.

   Пример:

   import turtle
   
   def draw_star():
       for _ in range(5):
           t.forward(100)
           t.right(144)
   
   t = turtle.Turtle()
   
   for _ in range(6):
       draw_star()
       t.forward(100)
       t.right(60)
   
   turtle.done()
   

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

   Пример:

   import turtle
   
   t = turtle.Turtle()
   colors = ["red", "orange", "yellow", "green", "blue"]
   
   for i in range(36):
       t.color(colors[i % 5])
       t.forward(100)
       t.right(170)
   
   turtle.done()
   

5. Использование рекурсии для сложных узоров:
   • Рекурсивные функции позволяют создавать сложные узоры, используя принцип самоподобия. Функция вызывает сама себя с изменяющимися параметрами.

     import turtle
     
     t = turtle.Turtle()
     turtle.bgcolor('black')
     t.color('blue','yellow')
     t.speed(0)
     
     
     def recursive_pattern(length, depth):
         if depth == 0:
             return
         else:
             t.forward(length)
             t.left(45)
             recursive_pattern(length / 2, depth - 1)
             t.right(90)
             recursive_pattern(length / 2, depth - 1)
             t.left(45)
             t.backward(length)
     
     
     t.speed(0)
     recursive_pattern(300, 7)
     
     turtle.done()

Задания на закрепление темы

1. Простой квадратный узор:
   • Нарисуйте квадратный узор, состоящий из 4 квадратов, каждый со стороной 50 пикселей.
2. Солнце:
   • Нарисуйте излучающие лучи, напоминающие солнце, с центральным кругом диаметром 100 пикселей.
3. Геометрический узор:
   • Создайте узор, включающий круг, треугольник и прямоугольник, повторенные в цикле.
4. Радужные круги:
   • Нарисуйте несколько концентрических кругов разных цветов, чтобы создать радужный эффект.
5. Спираль:
   • Нарисуйте спираль, используя чередующиеся цвета.
6. Цветной вихрь:
   • Нарисуйте вихрь, используя разные цвета и изменяя размеры.
7. Пирамида:
   • Нарисуйте трехмерную пирамиду, где каждый уровень пирамиды имеет разный цвет.
8. Фрактал:
   • Используя рекурсию, нарисуйте фрактал, например, фрактальное дерево.
9. Абстрактный узор:
   • Создайте абстрактный узор, используя случайные цвета и формы.
10. Интерактивный рисунок:
    • Разработайте программу, которая рисует нечто интересное при движении мыши по холсту.

Импорт собственных изображений

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

Импорт изображений с помощью register_shape():

1. Подготовка изображения:
   • Первым шагом является подготовка изображения, которое вы хотите использовать. Изображение должно быть в формате GIF, и идеально иметь квадратные размеры.
2. Регистрация изображения:
   • Используйте метод register_shape() для регистрации вашего изображения. Например:

     turtle.register_shape("my_image.gif")
     

3. Использование изображения:
   • После регистрации вы можете использовать ваше изображение в качестве формы черепахи:

     t.shape("my_image.gif")
     

Пример использования изображения в рисунке:

import turtle

# Регистрация изображения
turtle.register_shape("flower.gif")

# Создание черепахи с формой изображения
t = turtle.Turtle()
t.shape("flower.gif")
t.speed(2)

# Рисование с использованием изображения
t.forward(100)
t.left(90)
t.circle(50)

turtle.done()

В этом примере изображение «flower.gif» зарегистрировано и используется в качестве формы черепахи для рисования. Убедитесь, что ваше изображение находится в том же каталоге, что и ваш скрипт, или предоставьте полный путь к файлу.

Использование нескольких объектов turtle с разными изображениями:

import turtle

# Регистрация изображений
turtle.register_shape("flower.gif")
turtle.register_shape("star.gif")

# Создание черепах с разными формами
t1 = turtle.Turtle()
t1.shape("flower.gif")
t1.speed(2)

t2 = turtle.Turtle()
t2.shape("star.gif")
t2.speed(2)

# Рисование с использованием разных изображений
t1.forward(100)
t1.left(90)
t1.circle(50)

t2.backward(100)
t2.right(90)
t2.circle(50)

turtle.done()

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

Какие форматы изображений допустимы для объектов turtle в качестве shape?

В модуле Turtle в Python допустимы следующие форматы изображений для использования в качестве формы черепахи (shape):

1. GIF: Это наиболее распространенный формат для форм черепахи в Turtle. Модуль Turtle автоматически поддерживает изображения в формате GIF.
2. PGM: Также поддерживается формат изображения PGM (Portable Gray Map). PGM представляет собой простой формат хранения изображений в оттенках серого.
3. PPM: Это формат изображения PPM (Portable Pixmap), который поддерживается модулем Turtle.
4. XBM: X BitMap (XBM) — это формат изображения в виде текстового файла, который также может быть использован в Turtle.

При использовании метода register_shape() в Turtle, вы должны указать полное имя файла с расширением, например, "my_shape.gif" или "my_shape.pgm". Убедитесь, что изображение находится в том же каталоге, что и ваш скрипт, или предоставьте полный путь к файлу.

Как импортировать рисунок черепахи из ранее нарисованных фигур?

Инструкция по созданию shape из ранее нарисованных фигур:

1. Рисуйте фигуру: Используйте команды Turtle для рисования желаемой фигуры. В приведенном примере рисуется звезда.
2. Зафиксируйте фигуру: Используйте begin_fill() и begin_poly() для начала заливки и записи вершин фигуры.
3. Завершите фигуру: Используйте end_fill() и end_poly() для завершения заливки и записи вершин фигуры.
4. Получите вершины фигуры: Используйте get_poly() для получения записанных вершин фигуры.
5. Поднимите перо и переместитесь: Используйте up() и goto() для поднятия пера и перемещения черепахи в новое место (если необходимо).
6. Создайте композитную форму: Используйте Shape("compound"), чтобы создать композитную форму, и addcomponent() для добавления записанных вершин и цветов.
7. Зарегистрируйте форму: Используйте register_shape() для регистрации созданной формы под определенным именем.
8. Установите форму черепахи: Используйте shape() для установки формы черепахи в зарегистрированную форму.

from turtle import *

# Устанавливаем цвет и размер пера
color('red', '#00FFCC')
pensize(3)

# Устанавливаем максимальную скорость черепахи
speed(0)

# Начинаем заливку для будущей формы
begin_fill()
# Начинаем запись вершин многоугольника
begin_poly()

# Рисуем многоугольник (звезду)
while True:
    forward(400)
    left(170)
    print(pos())
    if abs(pos()) < 1:
        break

# Завершаем заливку и запись вершин многоугольника
end_fill()
end_poly()

# Получаем записанные вершины многоугольника
p = get_poly()

# Поднимаем перо и перемещаемся в начальные координаты
up()
goto(-200, 200)

# Создаем композитную форму с заданными компонентами и цветами
s = Shape("compound")
s.addcomponent(p, "blue", "red")

# Регистрируем созданную форму под именем "MyShape"
register_shape("MyShape", s)

# Устанавливаем форму черепахи в созданную форму
shape("MyShape")

Обработка событий в turtle

В Turtle Python, вы можете обрабатывать различные события, такие как события мыши, клавиатуры и таймера.

События мыши:

• Клик мыши:

  turtle.onscreenclick(my_function)
  

• Движение мыши:

  turtle.onscreendrag(my_function)
  

События клавиатуры:

• Нажатие клавиши:

  turtle.onkey(my_function, "a")
  

• Отпускание клавиши:

  turtle.onkeyrelease(my_function, "a")
  

• Нажатие клавиши и удержание:

  turtle.listen()  # включить прослушивание клавиш
  turtle.onkeypress(my_function, "a")
  

Таймер:

• Таймер с заданным интервалом:

  turtle.ontimer(my_function, 1000)  # 1000 миллисекунд (1 секунда)
  

Другие события:

• Изменение размеров окна:

  turtle.getcanvas().bind("<Configure>", my_function)
  

• Закрытие окна:

  turtle.bye()
  

Пример обработки событий:

import turtle

def on_click(x, y):
    turtle.circle(50)

def on_keypress():
    turtle.forward(30)

def on_timer():
    turtle.right(45)

def on_resize(event):
    turtle.write("Window resized!", align="center", font=("Arial", 16, "normal"))

# Обработка событий мыши
turtle.onscreenclick(on_click)

# Обработка событий клавиатуры
turtle.listen()
turtle.onkeypress(on_keypress, "Up")

# Обработка событий таймера
turtle.ontimer(on_timer, 5000)  # Через 5 секунд

# Обработка события изменения размера окна
turtle.getcanvas().bind("<Configure>", on_resize)

turtle.done()

Обработчики событий мыши в Turtle:

Обработчики событий мыши в Turtle предоставляют доступ к различным событиям, таким как клики мыши, движение мыши и другие. Обработчики могут быть привязаны к различным событиям мыши с использованием методов onscreenclick() и onscreendrag(). Давайте рассмотрим, какие параметры принимают эти обработчики:

1. onscreenclick() — вызывается при клике на экране:

   turtle.onscreenclick(my_function, button=1, add=None)
   

   • my_function(x, y): Функция, которая будет вызвана при клике. Параметры x и y представляют собой координаты, где произошел клик.
   • button: Кнопка мыши, которую нужно обрабатывать. Значение по умолчанию — 1 (левая кнопка мыши).
   • add: Если add равно True, то функция добавляется к уже существующим обработчикам.
2. onscreendrag() — вызывается при перетаскивании мыши на экране:

   turtle.onscreendrag(my_function, button=1, add=None)
   

   • my_function(x, y): Функция, которая будет вызвана при перетаскивании. Параметры x и y представляют собой новые координаты мыши.
   • button: Кнопка мыши, которую нужно обрабатывать. Значение по умолчанию — 1 (левая кнопка мыши).
   • add: Если add равно True, то функция добавляется к уже существующим обработчикам.

Пример простого кликера с подсчетом очков:

import turtle

score = 0

def on_click(x, y):
    global score
    score += 1
    print(f"Клик! Очки: {score}")

turtle.onscreenclick(on_click)

turtle.mainloop()

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

import turtle

def on_drag(x, y):
    turtle.ondrag(None)  # Отключаем текущий обработчик, чтобы избежать рекурсии
    turtle.goto(x, y)
    turtle.ondrag(on_drag)  # Повторно включаем обработчик

turtle.shape("circle")
turtle.color("red")
turtle.penup()

turtle.ondrag(on_drag)

turtle.mainloop()

Установка собственного курсора мыши в Turtle:

Да, вы можете установить собственный курсор мыши в Turtle, используя метод turtle.getcanvas().config(cursor="ваш_курсор"). Например:

import turtle

turtle.getcanvas().config(cursor="arrow")  # Замените "arrow" на любой другой курсор по вашему выбору

turtle.mainloop()

Вы можете выбрать различные курсоры, такие как «arrow», «turtle», «circle», «square» и многие другие. Вместо «ваш_курсор» укажите тот, который вам нравится.

Как импортировать собственное изображение для курсора мыши?

В модуле Turtle библиотеки Python нет прямого метода для создания и импортирования собственных курсоров мыши. Однако, вы можете использовать стандартные курсоры, предоставляемые библиотекой, или установить стандартные курсоры операционной системы. Если вам нужен специфический курсор, вы можете создать изображение в формате GIF, а затем использовать его в качестве курсора черепахи.

Вот пример, как вы можете создать и использовать собственный курсор:

import turtle

# Создаем изображение для курсора
turtle.register_shape("custom_cursor", ((0, 0), (10, -5), (0, -10)))

# Устанавливаем курсор
turtle.getcanvas().config(cursor="custom_cursor")

# Ваш код для работы с черепахой

turtle.mainloop()

В приведенном примере создается изображение для курсора, представленное кортежем вершин. Это изображение затем регистрируется с именем «custom_cursor» с помощью turtle.register_shape(). После этого устанавливается курсор, используя turtle.getcanvas().config(cursor="custom_cursor").

Заметьте, что размер изображения курсора должен быть кратным 8, так как это требование Tkinter (библиотеки, на которой основана Turtle). Размер стандартных курсоров — 16×16 пикселей. Вы можете изменить размер изображения в соответствии с вашими требованиями.

Перечень стандартных курсоров, которые можно использовать

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

1. «arrow» — Стандартная стрелка.
2. «turtle» — Стрелка в форме черепахи.
3. «circle» — Круглая точка.
4. «square» — Квадратная точка.
5. «triangle» — Треугольная точка.
6. «cross» — Крест.
7. «plus» — Плюс.
8. «watch» — Часы.
9. «heart» — Сердце.
10. «pencil» — Карандаш.
11. «ibeam» — Вставка (курсор текстового редактора).
12. «plus» — Курсор с плюсом.
13. «right_arrow» — Стрелка вправо.
14. «left_arrow» — Стрелка влево.
15. «up_arrow» — Стрелка вверх.
16. «down_arrow» — Стрелка вниз.
17. «circle» — Круглая точка.
18. «dot» — Точка.
19. «sizing» — Курсор изменения размера.

Что делает turtle.mainloop()?

turtle.mainloop() — это команда в библиотеке Turtle в Python, которая запускает бесконечный цикл событий (event loop) и предоставляет окну черепахи Turtle продолжать работу и обрабатывать события до тех пор, пока окно не будет закрыто пользователем.

Когда программа на Turtle завершает выполнение своего кода, она должна перейти в режим ожидания событий (event-driven mode). turtle.mainloop() выполняет эту функцию, обеспечивая бесконечный цикл, который ожидает и обрабатывает различные события, такие как клики мыши, движения мыши, нажатия клавиш и так далее.

Обработка событий клавиатуры в Turtle:

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

1. onkey() — вызывается при нажатии клавиши.

   turtle.onkey(my_function, "a")
   

   • my_function(): Функция, которая будет вызвана при нажатии клавиши.
   • "a": Клавиша, которую нужно обрабатывать.
2. onkeyrelease() — вызывается при отпускании клавиши.

   turtle.onkeyrelease(my_function, "a")
   

   • my_function(): Функция, которая будет вызвана при отпускании клавиши.
   • "a": Клавиша, которую нужно обрабатывать.
3. onkeypress() — вызывается при удержании клавиши.

   turtle.onkeypress(my_function, "a")
   

   • my_function(): Функция, которая будет вызвана при удержании клавиши.
   • "a": Клавиша, которую нужно обрабатывать.

Параметры функций-обработчиков:

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

Пример с функцией-обработчиком, принимающей параметры:

import turtle

def on_keypress(x, y):
    print(f"Клавиша нажата! Координаты мыши: ({x}, {y})")

turtle.onscreenclick(on_keypress)

turtle.mainloop()

В этом примере функция-обработчик on_keypress принимает координаты мыши как параметры.

Задание клавиш:

• Стандартные клавиши могут быть указаны как обычные символы (например, «a», «b») или специальные клавиши (например, «Up», «Down», «Left», «Right», «Return», «Shift», «Control», «Alt», и т.д.).
• Для указания специальных клавиш, используйте их имена в кавычках. Например:

  turtle.onkey(my_function, "Up")
  

• Можно также использовать сочетания клавиш:

  turtle.onkey(my_function, "Control-a")
  

Задание клавиши по коду:

• Вместо указания символа клавиши, вы можете использовать ее код. Например:

  turtle.onkey(my_function, "a")   # Обычная клавиша "a"
  turtle.onkey(my_function, "A")   # Та же клавиша "a", но с удержанием Shift
  turtle.onkey(my_function, "97")  # Код клавиши "a"
  

• Здесь код клавиши «a» равен 97.

Отличие listen() от mainloop()

В модуле Turtle в Python listen() и mainloop() выполняют разные функции в контексте обработки событий и выполнения программы:

1. listen():
   • listen() используется для включения прослушивания событий, таких как нажатия клавиш, клики мыши и другие.
   • Этот метод нужен, чтобы Turtle начал ожидать ввода пользователя и начал реагировать на события.
   • После вызова listen(), Turtle будет ожидать событий, но программа не будет блокирована. Вместо этого Turtle продолжит выполнять код в основном потоке программы, а события будут обработаны в фоновом режиме.
   • Используйте listen(), когда вы хотите включить ожидание событий, но при этом продолжить выполнение других частей кода.
2. mainloop():
   • mainloop() запускает бесконечный цикл событий, который слушает и обрабатывает события, такие как нажатия клавиш, клики мыши и другие.
   • Этот метод блокирует выполнение кода, пока окно Turtle не будет закрыто.
   • mainloop() используется для поддержания интерактивности и обработки событий в течение всего времени работы программы. Это завершает выполнение программы только после закрытия окна.
   • Используйте mainloop(), когда вы хотите, чтобы ваша программа оставалась открытой и реагировала на события в течение всего времени выполнения.

import turtle

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

# Ваш код для работы с черепахой

# Запускаем бесконечный цикл событий
turtle.mainloop()

Событие таймера и его обработчики в Turtle:

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

Включение и выключение таймера:

• • Включение таймера:

    turtle.ontimer(my_function, delay)
    

    • my_function(): Функция, которая будет вызвана по истечении времени.
    • delay: Интервал времени в миллисекундах до вызова функции.

• Выключение таймера:

  turtle.ontimer(my_function, delay)
  turtle.bye()
  

  • my_function(): Функция, которая была запланирована для вызова.
  • delay: Интервал времени, который оставался до вызова функции.

Примеры использования таймера:

1. Простой таймер для анимации:

   import turtle
   
   def move_turtle():
       turtle.forward(10)
       turtle.ontimer(move_turtle, 100)  # Повторить через 100 миллисекунд
   
   move_turtle()
   
   turtle.mainloop()
   

2. Таймер с отключением:

   import turtle
   
   def stop_animation():
       turtle.bye()
   
   turtle.ontimer(stop_animation, 5000)  # Остановить через 5 секунд
   
   turtle.mainloop()
   

Обработчики таймера:

Вы также можете использовать turtle.ontimer() для реализации периодического выполнения кода:

import turtle

def periodic_task():
    print("Выполняю периодическую задачу")
    # Добавьте свой код здесь
    turtle.ontimer(periodic_task, 1000)  # Вызвать снова через 1 секунду

# Включаем первоначальный запуск
turtle.ontimer(periodic_task, 1000)

turtle.mainloop()

В этом примере periodic_task будет выполняться каждую секунду. Когда код внутри функции выполнен, мы снова используем turtle.ontimer() для планирования следующего выполнения через 1000 миллисекунд.

Задания для тренировки

Задание 11: «Лови мишень». Создай простую игру, в которой черепаха будет «ловить» мишень, представленную кругом на экране. При каждом успешном попадании увеличивай счет.

import turtle
import random

score = 0

def move_target():
    target.goto(random.randint(-200, 200), random.randint(-200, 200))

def on_click(x, y):
    global score
    if target.distance(turtle.position()) < 20:
        score += 1
        print(f"Попадание! Очки: {score}")
    move_target()

# Инициализация мишени
target = turtle.Turtle()
target.shape("circle")
target.penup()
move_target()

# Настройка черепахи
turtle.shape("turtle")
turtle.speed(2)

# Установка обработчика для клика
turtle.onscreenclick(on_click)

turtle.done()

Задание 12: «Избегай препятствий». Создай игру, где черепаха должна избегать препятствий, представленных квадратами, которые случайным образом появляются на экране.

import turtle
import random

def create_obstacle():
    obstacle = turtle.Turtle()
    obstacle.shape("square")
    obstacle.color("red")
    obstacle.penup()
    obstacle.speed(0)
    obstacle.goto(random.randint(-200, 200), random.randint(-200, 200))
    return obstacle

def on_collision():
    turtle.color("red")
    print("Игра окончена!")

# Настройка черепахи
turtle.shape("turtle")
turtle.speed(2)

# Создание препятствий
obstacles = [create_obstacle() for _ in range(5)]

# Установка обработчика для проверки коллизии
turtle.ontimer(on_collision, 5000)  # Проверка коллизии каждые 5 секунд

turtle.done()

Задание 13: «Лабиринт». Создай игру, где черепаха должна пройти лабиринт, представленный стенами, используя стрелки клавиатуры.

import turtle

def go_up():
    turtle.setheading(90)
    turtle.forward(20)

def go_down():
    turtle.setheading(270)
    turtle.forward(20)

def go_left():
    turtle.setheading(180)
    turtle.forward(20)

def go_right():
    turtle.setheading(0)
    turtle.forward(20)

# Настройка черепахи
turtle.shape("turtle")
turtle.speed(2)

# Настройка лабиринта (просто пример)
turtle.penup()
turtle.goto(-100, 100)
turtle.pendown()
turtle.forward(200)
turtle.right(90)
turtle.forward(200)
turtle.right(90)
turtle.forward(200)
turtle.right(90)
turtle.forward(200)

# Установка обработчиков для стрелок клавиатуры
turtle.listen()
turtle.onkey(go_up, "Up")
turtle.onkey(go_down, "Down")
turtle.onkey(go_left, "Left")
turtle.onkey(go_right, "Right")

turtle.done()

Задание 14: «Плавающий остров». Создай игру, в которой черепаха находится на «плавучем острове», который постепенно тонет. Цель игрока — перемещаться вверх, чтобы избежать погружения под воду.

import turtle

water_level = -100

def rise_island():
    island.goto(0, island.ycor() + 20)
    if island.ycor() > water_level:
        turtle.ontimer(rise_island, 1000)  # Вызвать повторно через 1 секунду

# Настройка черепахи
turtle.shape("turtle")
turtle.speed(2)

# Создание "плавучего острова"
island = turtle.Turtle()
island.shape("square")
island.color("brown")
island.shapesize(stretch_wid=2, stretch_len=4)
island.penup()
island.goto(0, water_level)

# Установка обработчика для подъема острова
turtle.ontimer(rise_island, 1000)  # Подъем острова каждую секунду

turtle.done()

Задание 15: «Пинг-понг». Создай простую игру в пинг-понг, где две черепахи представляют ракетки, а мяч двигается между ними.

import turtle

# Настройка ракеток
left_racket = turtle.Turtle()
left_racket.shape("square")
left_racket.color("blue")
left_racket.shapesize(stretch_wid=1, stretch_len=5)
left_racket.penup()
left_racket.goto(-250, 0)

right_racket = turtle.Turtle()
right_racket.shape("square")
right_racket.color("red")
right_racket.shapesize(stretch_wid=1, stretch_len=5)
right_racket.penup()
right_racket.goto(250, 0)

# Настройка мяча
ball = turtle.Turtle()
ball.shape("circle")
ball.color("green")
ball.penup()
ball.goto(0, 0)
ball.dx = 2  # скорость по x
ball.dy = 2  # скорость по y

# Функции для движения ракеток
def move_left_racket_up():
    left_racket.sety(left_racket.ycor() + 20)

def move_left_racket_down():
    left_racket.sety(left_racket.ycor() - 20)

def move_right_racket_up():
    right_racket.sety(right_racket.ycor() + 20)

def move_right_racket_down():
    right_racket.sety(right_racket.ycor() - 20)

# Установка обработчиков для клавиш
turtle.listen()
turtle.onkey(move_left_racket_up, "w")
turtle.onkey(move_left_racket_down, "s")
turtle.onkey(move_right_racket_up, "Up")
turtle.onkey(move_right_racket_down, "Down")

# Основной игровой цикл
while True:
    # Движение мяча
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # Отскок от верхней и нижней границ
    if ball.ycor() > 290 or ball.ycor() < -290:
        ball.dy *= -1

    # Отскок от ракеток
    if (
        (ball.xcor() > 240 and ball.xcor() < 250)
        and (ball.ycor() < right_racket.ycor() + 50 and ball.ycor() > right_racket.ycor() - 50)
        or
        (ball.xcor() < -240 and ball.xcor() > -250)
        and (ball.ycor() < left_racket.ycor() + 50 and ball.ycor() > left_racket.ycor() - 50)
    ):
        ball.dx *= -1

    # Проверка на выход мяча за пределы поля
    if ball.xcor() > 290 or ball.xcor() < -290:
        ball.goto(0, 0)
        ball.dx *= -1

turtle.done()

Анимация в turtle

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

В Turtle для создания анимации используется комбинация методов для перемещения, изменения формы и цвета, а также обновления экрана в каждом кадре.

Использование метода clear() для анимации:

Метод clear() используется для очистки следа черепахи на экране. Он позволяет создавать плавные анимации, стирая предыдущий кадр перед отрисовкой следующего.

Пример анимации, в которой черепаха двигается по спирали, стирая предыдущий след:

import turtle

turtle.speed(2)
turtle.pensize(2)

for i in range(36):
    turtle.forward(10 + i * 5)
    turtle.right(25)
    turtle.clear()

turtle.done()

Пример анимации машущего флага:

import turtle

def draw_flag():
    turtle.speed(0)
    turtle.color("green")
    turtle.begin_fill()
    for _ in range(4):
        turtle.forward(50)
        turtle.right(90)
    turtle.end_fill()

turtle.speed(1)
turtle.hideturtle()
for _ in range(10):
    
    draw_flag()
    turtle.speed(1)
    turtle.penup()
    turtle.forward(10)
    turtle.pendown()
    turtle.clear()
    draw_flag()
    turtle.speed(1)
    turtle.penup()
    turtle.bk(10)
    turtle.pendown()
    turtle.clear()

turtle.done()

Пример анимации черепахи, оставляющей след:

import turtle

turtle.speed(1)
turtle.pensize(3)

for _ in range(36):
    turtle.forward(10)
    turtle.right(10)
    turtle.clear()

turtle.done()

Как скрыть и показать черепаху?

Для скрытия и показа черепахи в модуле Turtle в Python используются методы turtle.hideturtle() и turtle.showturtle(), соответственно.

Пример скрытия и показа черепахи:

import turtle

# Настройка черепахи
my_turtle = turtle.Turtle()

# Скрыть черепаху
my_turtle.hideturtle()

# Ваш код (например, рисование)

# Показать черепаху
my_turtle.showturtle()

turtle.done()

В этом примере, после создания черепахи (my_turtle), вызывается hideturtle(), чтобы скрыть ее. Затем идет ваш код, включая рисование или выполнение других действий с черепахой. После выполнения этих действий вызывается showturtle(), чтобы снова показать черепаху.

Как узнать текущие координаты черепахи?

Для получения текущих координат черепахи в модуле Turtle в Python используется метод turtle.position() или свойство turtle.xcor() и turtle.ycor().

Примеры:

1. С использованием position():

   import turtle
   
   # Настройка черепахи
   my_turtle = turtle.Turtle()
   
   # Перемещение черепахи
   my_turtle.forward(100)
   
   # Получение текущих координат
   current_position = my_turtle.position()
   print("Текущие координаты:", current_position)
   
   turtle.done()
   

2. С использованием xcor() и ycor():

   import turtle
   
   # Настройка черепахи
   my_turtle = turtle.Turtle()
   
   # Перемещение черепахи
   my_turtle.forward(100)
   
   # Получение текущих координат
   x_coordinate = my_turtle.xcor()
   y_coordinate = my_turtle.ycor()
   
   print("Текущая x-координата:", x_coordinate)
   print("Текущая y-координата:", y_coordinate)
   
   turtle.done()
   

Метод turtle.position() возвращает кортеж (tuple) из двух значений, представляющих текущие координаты черепахи. Каждое значение в кортеже соответствует координате по оси x и y, соответственно.

Задания на создание анимации

Задание 16: «Бегущая черепаха». Создайте анимацию бегущей черепахи, которая перемещается по экрану, оставляя за собой след. Можете добавить дополнительные эффекты, такие как изменение цвета следа.

import turtle

# Настройка черепахи
my_turtle = turtle.Turtle()
my_turtle.speed(2)
my_turtle.pensize(2)

# Анимация бегущей черепахи
for _ in range(100):
    my_turtle.forward(10)
    my_turtle.right(10)
    my_turtle.pencolor("blue")  # Изменение цвета следа

Задание 17: «Маятник». Создайте анимацию маятника, который качается влево и вправо. Добавьте изменение цвета маятника в зависимости от его положения.

import turtle

# Настройка черепахи
pendulum = turtle.Turtle()
pendulum.shape("square")
pendulum.shapesize(stretch_wid=5, stretch_len=1)
pendulum.color("red")

# Анимация маятника
for _ in range(180):
    pendulum.right(1)
    pendulum.pencolor((0, abs(pendulum.heading() % 180 - 90) / 90, 1))

Задание 18: «Калейдоскоп». Создайте анимацию, представляющую собой калейдоскопический узор. Используйте несколько черепах, чтобы создать сложные и повторяющиеся узоры.

import turtle

# Настройка черепах
turtle1 = turtle.Turtle()
turtle1.speed(5)

turtle2 = turtle.Turtle()
turtle2.speed(5)

# Анимация калейдоскопа
for _ in range(36):
    turtle1.forward(100)
    turtle1.right(45)
    turtle2.forward(100)
    turtle2.left(45)