Исполнитель Черепаха: знакомство с библиотекой turtle

На этой странице вы узнаете

• Сколько лет черепашьей графике?
• Может ли быть минус у нуля?
• С какой опасностью сталкивается Черепаха при отключении анимации?

Рассказы о героях, которые спасают мир, всегда пользуются большой популярностью, особенно когда они описываются яркими и запоминающимися образами. К примеру, Черепашки-ниндзя уже на протяжении многих лет радуют своих поклонников, борясь со злом, защищая город и помогая другим героям. Однако в данной статье мы рассмотрим иной аспект жизни этих героев, а именно как они могут помочь вам преодолеть страх перед 6 номером экзамена по информатике. С этой целью мы пригласили эксперта в программировании – гения Донателло, который научит вас использовать библиотеку turtle для создания красивых черепашьих рисунков. Готовы ли вы отправиться вместе с нами в увлекательное приключение и открыть новые грани возможностей черепашьего мира? Тогда давайте начнем!

Библиотека turtle

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

Черепаха (англ. turtle) в библиотеке – это имитационная модель графики на экране компьютера, где мы можем контролировать движение и поворот рептилии. 

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

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

Сколько лет черепашьей графике? Черепашья графика была придумана в 1960-х годах. Она была предложена советским ученым Сеймуром Пейпертом в рамках его работы по развитию образовательных методик и использованию компьютеров в обучении детей. Пейперт разработал концепцию черепашьей графики с целью использования программирования как инструмента для развития логического мышления у детей. Он предложил создать виртуальную черепашку, которая может перемещаться по экрану и оставлять след, чтобы дети могли визуализировать и контролировать результаты своего программного кода. С помощью черепашьей графики дети могут учиться программированию с помощью простых команд, таких как движение вперед, поворот и поднятие/опускание пера. Это позволяет им экспериментировать, создавать различные формы и рисунки, а также развивать навыки решения проблем и алгоритмического мышления. Черепашья графика была придумана в 1960-х годах, а библиотеку turtle на Python написали в 1992 году, спустя год после выпуска самого языка.

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

Основные команды

Библиотека предлагает широкий спектр команд, с помощью которых можно создать любые графические объекты. Например, мы можем нарисовать линии, круги, овалы, прямоугольники и многое другое. Каждая фигура состоит из набора линий, которые черепаха рисует при перемещении. Давайте посмотрим на основные функции и список команд библиотеки «turtle» в Python:

• forward(distance): перемещает черепашку вперед на определенное расстояние (в пикселях).
• backward(distance): перемещает черепашку назад на определенное расстояние.
• right(angle): поворачивает черепашку направо на указанный угол (в градусах).
• left(angle): поворачивает черепашку налево на указанный угол.
• penup(): поднимает перо черепашки, чтобы она не оставляла след при перемещении.
• pendown(): опускает перо черепашки, чтобы она начала оставлять след при перемещении.
• speed(speed): устанавливает скорость черепашки.
• tracer(n, delay): устанавливает задержку между обновлениями экрана во время рисования. Аргумент n определяет, через сколько шагов Черепашка должна обновлять экран, а delay — время задержки между обновлениями в миллисекундах.
• circle(radius): рисует окружность с указанным радиусом.

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

• pencolor(color) – задает цвет линии черепашки. color может быть строкой, содержащей название цвета (например, «red») или кортежем RGB (например, (255, 0, 0)).
• pensize(width) – задает толщину линии черепашки. width задает толщину линии в пикселях.
• fillcolor(color) – задает цвет заполнения для следующих нарисованных фигур. Аргумент color может быть в формате строки-названия цветов или кортежа RGB.
• begin_fill() – начинает заполнение для следующих нарисованных фигур.
• end_fill() – заканчивает заполнение последней нарисованной фигуры.
• bgcolor(color) – задает цвет фона окна.

Библиотека «turtle» дает возможность легко визуализировать программный код в Python и является отличным инструментом для обучения программированию. Вместо того чтобы просто видеть результаты своего кода в его текстовой форме, вы можете увидеть, как программа создает графические изображения в реальном времени. Это может быть очень полезно для визуального понимания работы вашего кода.

Вы изучили команды, а значит, теперь пора приступить к написанию первой программы! 

Первый запуск. Настройка окна

Библиотека «turtle» входит в стандартную библиотеку Python, поэтому для ее использования не требуется установка дополнительных пакетов. Она поставляется вместе с Python, поэтому может использоваться сразу после установки Python на устройство.

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

from turtle import *

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

И пропишем следующий код:

from turtle import *
showturtle()
done()

showturtle() – это функция из модуля turtle, которая отображает Черепаху на экране. Она делает её видимой (если она была скрыта) и перемещает ее в центр экрана.

done() – это функция из модуля turtle, которая открывает окно Turtle и запускает цикл обработки событий в бесконечном цикле, пока пользователь не закроет окно. В данном случае она останавливает программу только при закрытии окна пользователем.

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

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

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

У нас открывается Python Turtle Graphics.

Python Turtle Graphics – это графическое окно, в котором отображается черепаха с графическим пространством для рисования. 

Для задания размера окна можно использовать метод setup() с двумя параметрами: width (ширина окна) и height (высота окна). Например, чтобы создать окно шириной 500 пикселей и высотой 400 пикселей, следует дописать вот такую строчку:

setup(width=500, height=400)

Также возможны и другие варианты. Например, можно использовать метод screensize() для задания размеров холста черепахи. Этот метод также имеет два аргумента, width и height, и задает размеры холста Черепахи, а не размеры окна. 

Если холст больше размеров окна Python Turtle Graphics, то на экране будут появляться полосы прокрутки. Пусть размер окна у нас будет 500×400, а размер холста 1500×1400, задать это можно так:

setup(width=500, height=400)
screensize(1500, 1400)

Тогда при запуске программы мы получим следующий графический интерфейс:

Наконец, для того чтобы полностью заполнить окно размерами на экране, можно использовать команду screensize() без параметров:

setup(width=500, height=400)
screensize()

Данная команда заполнит окно размерами, доступными на текущем экране. 

Как вы уже могли заметить, в отличие от программы «КуМир», которую мы рассмотрели в статье «Исполнители Редактор и Черепаха», Черепашка в Python отображается в виде стрелочки. Кончик принято отображать как голову Черепашки, а сама стрелочка указывает направление движения рептилий.

Обратите внимание, что в модуле «turtle» в Python Черепашка по умолчанию смотрит вправо, вдоль положительной оси абсцисс, в то время как в языке программирования «КуМир» она смотрит вверх, вдоль положительной оси ординат. Важно учитывать положение ее головы, так как это определяет начальное направление движения и, следовательно, форму рисунка, который будет нарисован.

Движение и рисование

Воспользуемся изученными командами для создания простого рисунка – квадрата. Импортируем все функции из библиотеки, настраиваем нужные размеры окна. Давайте сдвинем Черепашку на 100 пикселей вперед с помощью команды forward():

from turtle import *
screensize()
forward(100)
done()

После запуска программы увидим следующую картинку:

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

Хвост Черепахи уже опущен и готов к рисованию, поэтому в самом начале  вызывать функцию pendown(), чтобы опустить хвостик, нет необходимости.

Теперь с помощью команды right() повернем голову Черепашки вправо на 90 градусов, чтобы линии были перпендикулярны. Выглядит это так:

from turtle import *
screensize()
forward(100)
right(90)
done()

Аналогично примеру, давайте нарисуем квадрат со сторонами в 100 пикселей: 

from turtle import *
setup(width=500, height=400)
forward(100)
right(90)
forward(100)
right(90)
forward(100)
right(90)
forward(100)
done()

Донателло чем-то недоволен… Ах, точно, автоматизация! Наш код содержит 4 одинаковых конструкции – поворот головы и движение вперед. Чтобы уменьшить объем кода и сделать его более лаконичным, имеет смысл использовать цикл for, чтобы эти действия выполнялись несколько раз подряд вместо повторения одинакового кода каждый раз. Это позволит избежать дублирования кода и уменьшить вероятность возникновения ошибок при его написании и поддержке.

from turtle import *
setup(width=500, height=400)
for i in range(4):
    forward(100)
    right(90)done()

Видите разницу? Мы смогли значительно улучшить внешний вид и понятность нашего кода, теперь он выглядит эстетично и хорошо читается. А при запуске получим следующую картинку:

Квадрат – это слишком скучно, говорит Донателло, он хочет показать нам что-то действительно великолепное! Хорошо, но для начала, давайте поднимем хвостик Черепахи, чтобы она не оставляла следы на рабочей области. Давайте также немного сдвинем ее влево, чтобы она не пересекала наш прекрасный квадрат при рисовании нового изумительного объекта. Для этого воспользуемся следующими командами:

from turtle import *
setup(width=500, height=400)
for i in range(4):
    forward(100)
    right(90)
penup()
goto(-100, 0)
done()

penup() – это функция, которая поднимает хвостик Черепашки. Таким образом, она перестает рисовать.

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

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

Попробуем запустить:

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

В мире черепашек-ниндзя герой Донателло обладает особым талантом и оружием – палочкой, которую он мастерски использует для создания искусных рисунков и боевых маневров. Он передал свои знания и техники Черепашке из библиотеки turtle, которая стала настоящим волшебником рисования. В модуле она использует свой хвост, чтобы создавать круги, оставляя за собой следы на пути.

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

Рисовать окружности мы можем с помощью ранее упомянутого метода circle(), передавая в качестве аргумента радиус окружности. Давайте начертим круг с радиусом в 50 пикселей. Для этого дополним код следующим образом:

from turtle import *
setup(width=500, height=400)
for i in range(4):
    forward(100)
    right(90)
penup()
goto(-100, 0)
pendown()
circle(50)
done()

После того как мы нашу Черепашку поставили в точку с координатой x = -100 и y = 0, мы готовы рисовать снова, поэтому вызываем функцию pendown() и задаем нашу окружность с помощью функции circle(). Получаем вот такой красивый рисунок с нашими замечательными фигурами:

Донателло заметил, что отрисовка фигур Черепашкой происходит слишком медленно. Чтобы решить эту проблему, он взял скейтборд Микеланджело, улучшил его и тем самым изобрел ускоритель speed, который позволяет указать скорость движения. Ускоритель принимает целое значение n, это скорость, с которой скейтборд будет везти Черепашку. Для увеличения скорости анимации на максимум необходимо прописать следующую строчку: speed(1000).

Функцию speed() нужно прописывать перед скриптом, ведь сначала мы садим Черепашку на скейтборд, а потом запускаем её.

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

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

Итак, давайте уберем все лишнее с нашей рабочей области: импортируем библиотеку, настроим размеры рабочего окна и нарисуем круг с радиусом в 100 пикселей, но прежде настроим наш хвостик, для этого воспользуемся функцией pen(), которые принимает следующие параметры:

• pencolor = название или код цвета (строковый тип данных);
• pensize = размер в пикселях (число).

Мы можем создать изображение аппетитной, хрустящей корочки пиццы, используя оранжевое перо и установив толщину линии на 4 пикселя.

from turtle import *
setup(width=500, height=400)
speed(1000)
pen(pencolor=’orange’, pensize=4)
circle(100)
done()

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

Если вы работаете в среде PyCharm, то для того, чтобы посмотреть, какие еще параметры принимает функция, зажмите на клавиатуре Ctrl и нажмите на название функции:

Давайте сдвинем окружность ниже, чтобы рисунок встал по центру. Для этого мы воспользуемся уже известной нам функцией goto(x, y). Однако, чтобы при перемещении Черепашка не оставила след, а как мы помним, по умолчанию ее хвостик опущен, нужно воспользоваться функцией penup(), а только после перемещения опустить перо с помощью pendown():

from turtle import *
setup(width=500, height=400)
speed(1000)
r = 100
penup()
goto(0, -r)
pendown()
pen(pencolor=’orange’, pensize=4)
circle(r)
done()

Микеланджело любит сырную пиццу, поэтому давайте применим желтую заливку. Делается это следующим образом:

1. С помощью функции fillcolor() мы можем выбрать цвет, которым будет заполнена область.
2. После того как мы выбрали цвет заливки, мы используем функцию beginfill() для указания черепашке, что она должна начать заполнять область указанным цветом.
3. Когда черепашка завершает заполнение, мы вызываем функцию endfill(), чтобы завершить процесс заливки и получить окончательный результат.

from turtle import *
setup(width=500, height=400)
speed(1000)
r = 100
penup()
goto(0, -r)
pendown()
pen(pencolor=’orange’, pensize=4)
fillcolor(‘yellow’)
begin_fill()
circle(r)
end_fill()
done()

Давайте разрежем пиццу на кусочки под углом 45 градусов. Так как круг составляет 360 градусов, нам потребуется 8 поворотов черепашки на 45 градусов, чтобы разделить пиццу на равные части. Мы будем поворачивать Черепашку на 45 градусов 8 раз и рисовать прямую линию, каждый раз возвращая рептилию в центр:

from turtle import *
setup(width=500, height=400)
speed(10)
r = 100penup()
goto(0, -r)
pendown()
pen(pencolor=’orange’, pensize=4)
fillcolor(‘yellow’)
begin_fill()
circle(r)
end_fill()
penup()
goto(0, 0)
pen(pensize=2)
pendown()
for i in range(8):
    goto(0, 0)
    left(45)
    forward(r)
done()

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

Центр тяжести – это точка с координатами (x, y), которая равноудалена от трех вершин треугольника. 

Сумма расстояний от центра тяжести до каждой вершины треугольника равна полупериметру треугольника (полупериметр – это сумма длин сторон треугольника, разделенная на 2).

Формулы для нахождения координат центра тяжести:

\(x =\frac{x_1 + x_2 + x_3}{3}\),

\(y =\frac{y_1 + y_2 + y_3}{3}\),

где \((x_1, y_1), (x_2, y_2), (x_3, y_3)\) – координаты вершин треугольника.

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

Для того чтобы узнать позицию Черепашки, используется функция position(). Итак, нам известен центр, это координата (0,0). Мы можем использовать функцию position() для определения мест, где заканчивается линия разреза, и добавить эти точки в список координат для дальнейших вычислений. Это выглядит так:

coord = []
for i in range(8):
    goto(0, 0)
    left(45)
    forward(r)
    coord.append(position())
# done()
print(coord)

Функция position() возвращает кортеж из двух элементов: x и y, поэтому coord будет являться списком кортежей. Например, если нам нужно взять точку x из третьей координаты, мы будем писать coord[2][0].

Может ли бы минус у нуля? Отрицательные нули могут возникать из-за того, как числа с плавающей точкой представлены внутри компьютера. Чаще всего список координат содержит числа с плавающей точкой, и иногда результаты вычислений с ней могут быть немного неточными из-за ограничений, связанных с хранением и представлением действительных чисел в двоичной форме. Убедится в этом вы можете запустив следующий код: from turtle import * tracer(0) coord = [] for i in tange(4):     coord.append(position())     forward(100)     right(120) print(coord) Чтобы избежать подобной проблемы с отрицательными нулями или малыми погрешностями, вы можете округлить значения координат до нужного количества десятичных знаков перед добавлением их в список. Помимо этого, список координат нам нужно преобразовать в множество, чтобы удалить дубликаты. Вот так будет выглядеть наш преобразованный код: from turtle import * tracer(0) coord = [] for i in range(4):     pos_x, pos_y = position()     rounded_pos_x = round(pos_x, 2)     rounded_pos_y = round(pos_y, 2)     coord.append((rounded_pos_x, rounded_pos_y))     forward(100)     right(120) print(list(set(coord))) Помните, что -0.0 и 0.0 ведут себя одинаково в математических операциях, поэтому это не ошибка в коде или в работе модуля turtle. Просто имейте в виду, что числа с плавающей точкой могут иметь небольшие погрешности, и сравнивайте их с заданной точностью для избежания ошибок.

Координаты получены. Теперь давайте заведем список центров – будем добавлять в него результаты вычислений. Одна точка является фиксированной – это 0 и 0. Вторая точка будет текущей и определяется в цикле переменной i, а последующая будет иметь индекс i+1, соответственно, поэтому в цикле for укажем длину – 1. Однако для последней точки пары не найдется, именно поэтому давайте в конец массива centre продублируем первую координату, чтобы замкнуть цепь.

На этот раз будем рисовать кружки с помощью функции dot(), которая принимает на вход следующие аргументы:

• size — обязательный параметр, задающий толщину точки в пикселях;
• color — дополнительный параметр, задающий цвет точки.

coord.append(coord[0])
centre = []
for i in range(len(coord)-1):
    x = (0 + coord[i][0] + coord[i+1][0]) // 3
    y = (0 + coord[i][1] + coord[i + 1][1]) // 3
    centre.append((x,y))
fillcolor(‘red’)
for i in range(8):
    penup()
    goto(centre[i][0], centre[i][1])
    pendown()
    begin_fill()
    dot(30, ‘red’)
    end_fill()

Сырная пицца с колбасками готова! Но кажется, чего-то не хватает…

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

Свежая зелень не только прекрасно выглядит на любом блюде, но также и добавляет вкусовые качества и питательность, что делает её важным и неотъемлемым компонентом многих рецептов. Без неё просто не так вкусно и полезно! Наша задача – засыпать круг пиццы базиликом.

Из математики мы знаем, что уравнение окружности строится следующим образом: \((x-x_0)^2 + (y-y_0)^2 = r^2\).

Поэтому чтобы проверить, что наша координата лежит внутри этой окружности, нам нужно добавить следующее условие: \((x-x_0)^2 + (y-y_0)^2 <= r^2\).

Переменные x и у будем перебирать с помощью цикла for. Но для того чтобы наши точки не слиплись, необходимо задать расстояние между ними. Выполним следующий код:

from turtle import *


setup(width=500, height=400)
tracer(0)
r = 100penup()
goto(0, -r)
pendown()
pen(pencolor=’orange’, pensize=4)
fillcolor(‘yellow’)
begin_fill()
circle(r)
end_fill()
penup()
goto(0, 0)
pensize(2)
pendown()
coord = []
for i in range(8):
    goto(0, 0)
    left(45)
    forward(r)
    coord.append(position())
coord.append(coord[0])
centre = []
for i in range(len(coord) — 1):
    x = (0 + coord[i][0] + coord[i + 1][0]) // 3
    y = (0 + coord[i][1] + coord[i + 1][1]) // 3
    centre.append((x, y))
fillcolor(‘red’)
for i in range(8):
    penup()
    goto(centre[i][0], centre[i][1])
    pendown()
    begin_fill()
    dot(30, ‘red’)
    end_fill()
penup()
spacing = 15
for x in range(-r, r, spacing):
    for y in range(-r, r, spacing):
        if x ** 2 + y ** 2 < r ** 2:
            goto(x, y)
            dot(5, ‘green’)
done()

Отлично, это уже больше походит на пиццу! Как вы заметили, мы убрали параметр speed() и заменили его на параметр tracer(), чтобы отключить анимацию.

С какой опасностью сталкивается Черепаха, при отключении анимации? Функция tracer() в модуле turtle используется для управления задержкой обновления экрана во время рисования. Она может быть полезна для ускорения процесса рисования и создания анимаций, но также может иметь некоторые негативные побочные эффекты: 1. Потеря данных: Если вы используете tracer() с аргументом, отличным от 1, это означает, что Черепашка будет обновлять экран только после указанного количества шагов. В результате, некоторые промежуточные состояния черепашки могут быть пропущены, что может привести к потере данных и неправильному отображению рисунка. 2. Невозможность отслеживать прогресс: Если вы используете большое значение аргумента tracer(), то процесс рисования может занять значительное время. В таком случае, вы не сможете видеть промежуточные результаты и отслеживать прогресс черепашки. 3. Блокировка интерфейса: Если вы используете tracer(0), то экран не будет обновляться во время рисования до вызова функции update(). В результате, интерфейс может блокироваться, пока рисование не будет завершено, что может быть нежелательным для пользователей. Использование функции update() решает эти проблемы. Она позволяет обновлять экран в реальном времени, отображая промежуточные результаты рисования. Таким образом, вы сможете контролировать прогресс и увидеть все изменения, происходящие на экране. В целом, рекомендуется использовать функцию update() в сочетании с tracer(0), чтобы обеспечить правильное отображение рисунка и предотвратить возможные проблемы, связанные с потерей данных и блокировкой интерфейса.

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

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

Первая прямая нам известна, она равна \(y = 0\), вторая прямая проходит через угол в 45 градусов и имеет уравнение \(y = x\), а уравнение окружности нам известно.

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

spacing = 1
for x in range(-r, r, spacing):
    for y in range(-r, r, spacing):
        if x ** 2 + y ** 2 < r ** 2:
            if y > 0 and y < x:
                goto(x, y)
                dot(10, ‘white’)

Получим вот такой рисунок:

Теперь давайте разберемся, для чего все это нужно. Часто в задании 6 ЕГЭ вас просят найти количество точек, заключенных внутри фигуры, которую нарисовала Черепашка. Иногда можно использовать программу КуМир для подсчета таких точек, но когда фигура слишком большая и не помещается в области программы, это может вызвать трудности. Мы с вами изучили библиотеку turtle, которая позволяет создавать визуализацию фигур. Кроме того, мы обновили свои знания о формулах, которые используются для построения прямых, а также научились заливать определенную область фигуры точками. Теперь можно закрепить полученные знания на практике и перейти к решению реальных задач.

Практика

Задание. Исполнитель Черепаха действует на плоскости с декартовой системой

координат. В начальный момент Черепаха находится в начале координат, её голова направлена вдоль положительного направления оси ординат, хвост опущен. При опущенном хвосте Черепаха оставляет на поле след в виде линии. В каждый конкретный момент известно положение исполнителя и направление его движения. У исполнителя существует две команды: Вперёд n (где n – целое число), вызывающая передвижение Черепахи на n единиц в том направлении, куда указывает её голова, и Направо m (где m – целое число), вызывающая изменение направления движения на m градусов по часовой стрелке. Запись Повтори k [Команда1 Команда2 … КомандаS] означает, что последовательность из S команд повторится k раз
.
Черепахе был дан для исполнения следующий алгоритм:
Повтори 7 [Вперёд 10 Направо 120].

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

Решение. Импортируем библиотеку, задаем размер окошка, отключаем анимацию:

from turtle import *
setup(width=500, height=400)
tracer(0)

По условию голова Черепашки смотрит вдоль положительного направления оси ординат, а как мы помним, в python Черепашка по умолчанию смотрит вдоль положительного направления оси абсцисс, поэтому рептилию нужно повернуть влево на 90 градусов для правильности рисунка.

left(90)

Далее переводим заданный в условии алгоритм в код.

for i in range(7):
    forward(10)
    right(120)
    update()

После запуска мы увидим следующую картину:

Считать точки при таком масштабе довольно проблематично, поэтому увеличим его. Пускай 1 клетка = 20 пикселям. Для этого введем переменную spacing и будем шаг черепашки умножать на его значение:

from turtle import *
setup(width=500, height=400)
tracer(0)
spacing = 20left(90)
for i in range(7):
    forward(10 * spacing)
    right(120)
    update()

Теперь мы отчетливо видим равносторонний треугольник. Настроим сетку, ведь нам нужно подсчитать количество точек внутри данной фигуры.

Для этого введем два цикла for – для x и y. Зададим нашей сетке небольшой размер, например, 25×25. В цикле мы будем ставить Черепашку на подобранную координату и ставить точку размером в 5 пикселей – это будет оптимальный размер для визуализации, но вы можете взять другой размер с небольшой погрешностью так, чтобы точки не перекрывали друг друга.

И так как 1 клетка для нас это 20 пикселей, то перебираемые значения x и y так же необходимо умножить на 20.

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

penup()
for x in range(-size, size):
    for y in range(-size, size):
        goto(x * spacing, y * spacing)
        dot(5)done()

Итак, при запуске следующего кода

from turtle import *
setup(width=500, height=400)
tracer(0)
size, spacing = 25, 20left(90)
for i in range(7):
    forward(10 * spacing)
    right(120)
    update()
penup()
for x in range(-size, size):
    for y in range(-size, size):
        goto(x * spacing, y * spacing)
        dot(5)
done()

мы получаем такую картину:

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

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

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

from turtle import *
setup(width=500, height=400)
tracer(0)
size, spacing = 25, 20
left(90)
coord = []
for i in range(7):
    pos_x, pos_y = position()
    rounded_pos_x = round(pos_x, 2)
    rounded_pos_y = round(pos_y, 2)
    coord.append((rounded_pos_x, rounded_pos_y))
    forward(10 * spacing)
    right(120)
    update()
print(list(set(coord)))

Мы получим следующий вывод: [(173.21, 100.0), (0.0, 200.0), (0.0, 0.0)], это и есть вершины нашего треугольника.

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

\(k =\frac{y_2 — y_1}{ x_2 — x_1}\)

где \((x_1, y_1) = (0.0, 0.0)\) и \((x_2, y_2) = (173.21, 100.0)\). 

Подставляем известные значения и решаем:

\(k = \frac{100 — 0}{ 173.21 — 0}=0.577846..\)

Таким образом, значение k для данных точек равно приблизительно 0.577.

Преобразуем наш код. Теперь мы не будем рисовать сетку полностью. Если вышеуказанные условия выполняются на нашего x и y, перемещаем рептилию по указанной координате и ставим точку:

from turtle import *
setup(width=500, height=400)
tracer(0)
left(90)
r, spacing = 20, 20
for i in range(7):
    forward(10*spacing)
    right(120)
    update()
penup()
for x in range(-r, r):
    for y in range(-r, r):
        if (x > 0) and (y * spacing < -0.577 * x * spacing + 200) and (y * spacing> 0.577 * x * spacing):
            goto(x * spacing, y * spacing)
            dot(10, ‘red’)
done()

Теперь наш код выделяет точки внутри фигуру, но пусть он еще их и посчитает. Заведем счетчик cnt, который будем увеличивать внутри ветки if:

from turtle import *
setup(width=500, height=400)
tracer(0)
left(90)
r, spacing = 20, 20
for i in range(7):
    forward(10 * spacing)
    right(120)
    update()
penup()
cnt = 0
for x in range(-r, r):
    for y in range(-r, r):
        if (x > 0) and (y * spacing < -0.577 * x * spacing + 200) and (y * spacing > 0.577 * x * spacing):
            goto(x * spacing, y * spacing)
            dot(10, ‘red’)
            cnt += 1print(cnt)
done()

Ответ: 38

В результате прочтения данной статьи вы приобрели все необходимые знания для успешного выполнения задания 6 по информатике на ЕГЭ с помощью библиотеки turtle. Если вы желаете более эффективно решать задачи на языке Python, приглашаем вас ознакомиться с другими увлекательными статьями по этому языку программирования. Например, в статье «Практика работы с функциями» вы узнаете, как использовать функции для организации и повторного использования вашего кода.

Термины

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

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

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

Фактчек

• Библиотека Turtle в Python – это удобный инструмент для создания графических приложений. Она обеспечивает пользователей рядом функций и методов для быстрого создания графических изображений, включая различные фигуры и линии. Библиотека Turtle в основном используется для обучения программированию и создания графических рабочих пространств.
• Библиотека turtle предлагает широкий спектр команд для создания различных графических объектов, таких как линии, точки, круги и многое другое.
• Для увеличения скорости анимации черепашки можно использовать ускоритель speed(). Для отключения анимации используется функция tracer() в связке с функцией update().
• Для осуществления заливки фигур нужно использовать функции beginfill(), endfill(). Чтобы задать цвет заливки, используется функция fillcolor().
• Функция pen() позволяет установить параметры пера, такие как цвет и толщина линии. Чтобы начать рисование, нужно применить команду pendown(), которая опускает хвост Черепашки на бумагу. Аналогично, чтобы поднять хвост, необходимо вызвать функцию penup(). Кроме того, с помощью функции pensize() можно задать толщину линии непосредственно внутри написанного кода, а с помощью pencolor() установить цвет линии.

Проверь себя

Задание 1.
Какая функция устанавливает цвет заливки внутри фигур, нарисованных черепашкой?

1. fillcolor();
2. set_fill();
3. bgcolor();
4. set_bgcolor().

Задание 2.
Какая функция заставляет черепашку повернуться на заданный угол?

1. turn();
2. rotate();
3. set_angle();
4. left() / right().

Задание 3.
Какой метод используется для перемещения черепашки вперед на определенное расстояние?

1. forward();
2. backward();
3. left() / right();
4. turn().

Задание 4.
Какой метод используется для изменения цвета линии, которую рисует черепашка?

1. color();
2. fillcolor();
3. bgcolor();
4. pencolor().

Задание 5.
Какая функция из библиотеки turtle используется для рисования круга?

1. circle();
2. oval();
3. curve();
4. arc().

Ответы: 1. — 1; 2. — 4; 3. — 1;  4. — 4;  5. — 1.