Изучая обилие каналов в любимой телеге я увидел ссылку на плейлист Модуль turtle. Создаем графику в Python.
Чего уж говорить, а рост интереса к змейке игнорировать просто нельзя! Я уже молчу о том, что он занял все топы рекомендаций к изучению, а есть еще и машинное обучение, в котором без него сейчас просто никак.
Иными словами: хочешь быть в теме — учи Python. Ну и я начал учить, не то чтобы прям нырнул, но постепенно иду ко дну погружаюсь, разбираюсь.
Рекомендую к просмотру все эти видео, очень интересно. А тут я распишу основы работы с turtle и интересные моменты.
Писать все буду в своей любимой PyCharm, а если во время выполнения возникают ошибка похожая на ImportError: DLL load failed while importing _tkinter, то видимо у вас система 64 бит, а вот Python скачан для 32. Просто удалите его и скачайте заново, уточнив предварительно, какая у вас система.
Импорт черепашки
Ладно. Перейдем к самой Черепашке (Turtle). Создали новый проект, файлик, и приступаем.
Как и с любым модулем, для работы с turtle её нужно импортировать. Делаем это вот так:
Далее создадим объект библиотеки turtle, который назван Turtle. Значение запишем в переменную turtlePen.
turtlePen = turtle.Turtle()
| turtlePen = turtle.Turtle() |
Попробуем запустить? Если все выполнено правильно, то вы должны увидеть белое окно, которое тут же исчезнет, так как программа завершена.
Добавим переменную window, которая будет содержать объект Screen (Не забывайте о скобках ()!). С его помощью можно изменить параметры этого самого окна, вроде цвета фона или возможность сохранить окно даже после всех операций отрисовки.
Последнее нам и нужно, для этого добавляем в самый конец такую команду:
import turtle
turtlePen = turtle.Turtle()
window = turtle.Screen()
window.mainloop() # <- не даст закрыть окно
| turtlePen = turtle.Turtle()window.mainloop() # <- не даст закрыть окно |
Запускаем и видим:
Это прекрасно!
Рисуем при помощи Turtle!
Уже можно рисовать? Да!
Для этого управляем нашим turtlePen. Допустим, мы можем указать ему идти вперед на определенное расстояние.
Я художник!
Вперед — это в правую сторону из центра? Любая черепашка начинает с координаты (0;0), т.е. в центре экрана и смотрит в правую сторону.
Чтобы изменить направление движения используем команды left или right. Для примера нарисуем лесенку при помощи уже известных команд.
import turtle
turtlePen = turtle.Turtle()
window = turtle.Screen()
turtlePen.forward(30)
turtlePen.left(90)
turtlePen.forward(30)
turtlePen.right(90)
turtlePen.forward(30)
turtlePen.left(90)
turtlePen.forward(30)
turtlePen.right(90)
turtlePen.forward(30)
turtlePen.left(90)
turtlePen.forward(30)
turtlePen.right(90)
turtlePen.forward(30)
window.mainloop()
| turtlePen = turtle.Turtle() |
Выглядит кошмар, но на выходе получаем такую вот картинку:
Как и обещал
Можно увидеть, что у нас получилось очень много одинаковых команд, а потому для выполнения таких заданий разумно использовать циклы. А потому перепишем этот пример более корректно.
Обсудим скорость движения черепашки. При помощи команды speed мы можем изменять скорость рисования. Чем больше значение, тем быстрее рисует, но если укажем 0, то рисунок будет нарисован мгновенно.
Итак, версия ступени версия 2.0:
import turtle
turtlePen = turtle.Turtle()
window = turtle.Screen()
def draw_stairs(n, size=30): # <- создали функцию, для рисования
for i in range(0, n): # <- цикл нарисует указанное количество ступеней
turtlePen.left(90)
turtlePen.forward(size)
turtlePen.right(90)
turtlePen.forward(size)
turtlePen.speed(10)
draw_stairs(8) # <- вызов функции
window.mainloop()
| turtlePen = turtle.Turtle()def draw_stairs(n, size=30): # <- создали функцию, для рисования for i in range(0, n): # <- цикл нарисует указанное количество ступенейdraw_stairs(8) # <- вызов функции |
Уже лучше
Что насчет других геометрических фигур? Без проблем! Вот треугольник!
turtlePen.left(120)
turtlePen.forward(80)
turtlePen.left(120)
turtlePen.forward(80)
turtlePen.left(120)
turtlePen.forward(80) 
Похож ведь?
А это квардат:
turtlePen.left(90)
turtlePen.forward(80)
turtlePen.left(90)
turtlePen.forward(80)
turtlePen.left(90)
turtlePen.forward(80)
turtlePen.left(90)
turtlePen.forward(80) 
Стороны равны, гарантирую ????
Внимательные могли заметить, что и для правильного треугольника, и для квадрата, мы в сумме получаем поворот на 360 градусов, а значит можно создать функцию рисования правильных многоугольников!
Вот она:
def polygon(n, size=80):
if n > 2: # <- многоугольников меньше 3 углов я не знаю 🙂
angle = 360/n # <- получаем угол поворота в зависимости от количества углов
for n in range(0, n): # <- рисуем стороны
turtlePen.left(angle)
turtlePen.forward(size)
# рисуем разные фигуры
polygon(3)
polygon(4)
polygon(5)
polygon(6)
| if n > 2: # <- многоугольников меньше 3 углов я не знаю 🙂 angle = 360/n # <- получаем угол поворота в зависимости от количества углов for n in range(0, n): # <- рисуем стороны |
Для примера я выведу фигуры с 3, 4, 5 и 6 углами.
Все работает!
Если заметили, то я везде оставлял возможность менять длину стороны для каждой фигуры (2 параметр у каждой функции). Это вполне можно использовать для создания интересных узоров!
К примеру:
import turtle
turtlePen = turtle.Turtle()
window = turtle.Screen()
def polygon(n, size=80):
if n > 2:
angle = 360/n
for n in range(0, n):
turtlePen.left(angle)
turtlePen.forward(size)
turtlePen.speed(10)
for i in range(0, 100, 5):
polygon(3, 10 + i)
turtlePen.left(20)
window.mainloop()
| turtlePen = turtle.Turtle()for i in range(0, 100, 5): |
Один из вариантов…
Изменим треугольники на пятиугольники, и получим:
Все так же, но иначе
А этот цикл:
size = 40
for i in range(0, 80):
polygon(4, size)
turtlePen.left(5)
size = size + 3
Нарисует:
Нужно будет переместить центр…
Иными словами — экспериментируйте! Так можно получить самые интересные изображения.
А пока добавим всему этому красок!
Используем цвета
Фон окна можно изменить командой bgcolor, куда передаем имя текста в виде строки:
Выбор явно не лучший, но для примера сойдет ^_^. Далее буду использовать brown
Аналогично при помощи команды color указываем цвет для рисования:
turtlePen.color(«magenta»)
| turtlePen.color(«magenta») |
Думаю вполне неплохо
Цвет можно менять и во время рисования. Для этого создадим массив цветов и в зависимости от значения цикла (или иных параметров) будем менять цвет линий.
import turtle
turtlePen = turtle.Turtle()
window = turtle.Screen()
window.bgcolor(«black»)
def polygon(n, size=80):
if n > 2:
angle = 360 / n
for n in range(0, n):
turtlePen.left(angle)
turtlePen.forward(size)
turtlePen.speed(100)
colors = ['orange', 'cyan', 'blue', 'green', 'red']
size = 40
for i in range(0, 60):
turtlePen.color(colors[i % 5])
polygon(4, size)
turtlePen.left(5)
size = size + 3
window.mainloop()
| turtlePen = turtle.Turtle()colors = ['orange', 'cyan', 'blue', 'green', 'red'] turtlePen.color(colors[i % 5]) |
Цвет фона я сделал черным, чтобы максимально рассмотреть это цветовое безумие.
Все интереснее!
Если же вы хотите разрисовать конкретные стороны своих фигур, то цвет нужно указать в цикле отрисовки сторон (и убрать из цикла отрисовки фигур).
В итоге функция polygon должна выглядеть приблизительно так:
def polygon(n, size=80):
if n > 2:
angle = 360 / n
for n in range(0, n):
turtlePen.color(colors[n % 5])
turtlePen.left(angle)
turtlePen.forward(size)
| turtlePen.color(colors[n % 5]) |
А изображение получит совершенно новый вид:
Так даже круче!
Напоследок вспомним о кругах. Ведь наша программа рисует только многоугольники. И хотя можно указать какой-то 40-угольник, который в итоге даже будет похож на круг:
Ну почти. Зато красиво!
В программе есть для этого отдельная функция: circle. И заменив функцию polygon в цикле отрисовки:
for i in range(0, 70):
turtlePen.color(«white»)
turtlePen.circle(size)
turtlePen.left(5)
size = size + 3
Получаем очередной интересный узор, но только с кружками:
Лучше так, чем 40 угольник!
Спасибо за внимание! Жду отзывов и узоров ????
Черепашьи бега. by @Politick
Спасибо https://replit.com/@politick за предоставленный код.
Первым делом, при работе с черепахой, импортируем данную библиотеку в проект. Нам так же потребуется функция randint() из библиотеки random. Сразу после импорта научим нашу черепашку перемещаться. Для этого используем метод .forward() и вставим его в цикл for.
Мы научили нашу черепашку перемещаться, но обычная стрелка выглядит не очень привлекательно, давайте поменяем её на черепаху! Над циклом вставьте следующий код t.shape('turtle').
Теперь давайте нарисуем финишную черту, до которой необходимо будет добраться нашей черепашке. Используем методы .up() .goto() .down(). Данный код пишем над циклом. Должно получиться как на картинке ниже.
Мы видим, что наша черепашка не добегает до финишной черты. Можно увеличить количество итераций, но дело в том, что если мы передвинем нашу финишную черту влево или вправо, то наша черепашка будет либо забегать за черту, либо пересекать её и идти дальше. Поэтому, нам необходимо прекратить перемещать черепаху, как только она коснулась финишной черты.
Для этого лучше переписать цикл for на цикл while. Чтобы понять где сейчас находится черепаха, воспользуемся методом .xcor(). Этот метод возвращает текущую координату черепахи по оси x. Мы будем идти вперёд до тех пор, пока координата черепахи меньше координаты финишной черты. Координату x финишной черты мы можем узнать из метода .
goto(150,-60) — это первый аргумент который мы передаём. Переписываем цикл…
Теперь наша черепашка прекратит движение ровно на линии финиша.
И, казалось бы, на этом всё, но нет! Давайте устроим настоящие черепашьи бега! Поставим несколько черепашек на линию старта и заставим их бежать наперегонки! Как? Вся сила в ООП(Объектно Ориентированном Программировании)
Для начала, объявим список colors, который будет хранить цвета всех наших будущих гонщиков. А ниже объявим, пока что пустой, список наших будущих гонщиков. Пиши этот код перед тем как рисуешь финишную черту.
Теперь тебе необходимо создать участников гонки, цветом указанным в списке colors и расположить их друг под другом (т.е. меняя координату y) на стартовой позиции. Кстати, не забудьте скрыть стрелку, которая рисует финишную черту. Она у нас в гонке не участвует ????Будте внимательны, прочитайте комментарии к коду.
При выходе из цикла у нас будет полностью заполненный список с участниками гонки, каждый своего цвета и каждый на своей стартовой позиции. Самое время объявить старт нашей гонки и заставить стремительно следовать к черте финиша каждую черепашку.
Каждый наш участник является объектом класса Turtle и ему доступны все методы которые мы могли применять к нашей черепашке. Объявим переменную racing и присвоим ей значение True.
ГОНКА НАЧАЛАСЬ!!! Теперь, пока гонка хранит True, все участники будут постепенно перемещаться к финишной черте, но как только один из участников пересечёт финишную черту, сразу же прекращаем гонку, присвоив переменной racing значение False.
Можно удалить написанный ранее цикл while и написать новый, или переписать его.
Но ещё не всё так гладко. Сейчас все наши черепашки одновременно пересекают финишную черту.
«Черепашья графика» при помощи turtle, рисование при помощи алгоритма
Черепашья графика, turtle – принцип организации библиотеки графического вывода, построенный на метафоре Черепахи, воображаемого роботоподобного устройства, которое перемещается по экрану или бумаге и поворачивается в заданных направлениях, при этом оставляя (или, по выбору, не оставляя) за собой нарисованный след заданного цвета и ширины.
Проще: черепашка ползает по экрану и рисует. Мы управляем черепашкой на плоскости при помощи программы.
Начало работы. Движения
В первой строке необходимо добавить:
import turtle
Мы командуем черепашкой простыми словами на английском языке.
left, right – поворот налево и направо, forward и backward – движение вперед и назад. В программе каждое действие – вызов функции из модуля turtle. Простая программа:
import turtle
turtle.right(90)
turtle.forward(100)
turtle.left(90)
turtle.backward(100)
Что произошло:
- Поворот направо на 90 градусов
- Движение вперед на 100 шагов (пикселей)
- Поворот налево на 90 градусов
- Движение назад на 100 шагов
Не похоже на черепашку, это ползающая стрелка! Исправим это:
import turtle
turtle.shape(«turtle»)
turtle.fd(100)
turtle.exitonclick()
Отлично! Теперь это черепашка, пусть и монохромная. Дополнительно, функция exitonclick() позволяет закрыть окно и завершить выполнение программы кликом мышкой по окну. А еще можно использовать сокращенные названия функций: fd(100) вместо forward(100),
rt вместо right, lt вместо left, bk вместо backward.
Геометрические фигуры
Рисуем простые геометрические фигуры:
- Прямая: просто движение вперед
- Квадрат: вперед, поворот на 90 градусов и так 4 раза. Повторение команд – значит, можно выполнить их в цикле for!
- Пятиконечная звезда: вперед, поворот на 144 градусов и так 5 раз.
Если мы хотим выполнить инструкции n раз, мы пишем их в цикле
for i in range(n):
Далее идут инструкции с отступом в 4 пробела. Код с отступами – тело цикла. Когда цикл завершается, отступы больше не ставятся.
Рисуем квадрат:
import turtle
square = turtle.Turtle()
square.shape(«turtle»)
for i in range(4):
square.forward(100)
square.right(90)
turtle.exitonclick()
Скучно рисовать одинокие фигуры. Поэтому мы приготовились рисовать сразу несколько и теперь создаем отдельный экземпляр класса Turtle для каждой фигуры.
Так мы можем менять цвет линии и другие параметры отдельно для каждой фигуры.
Потом, когда мы захотим дорисовать или изменить параметры фигуры, у нее будут сохранены старые параметры.
Их не надо будет устанавливать заново, как это было бы без отдельных экземпляров класса для каждой фигуры.
Звезда рисуется также:
Самостоятельно:
- Нарисуйте пятиконечную звезду (угол поворота 144 градуса).
- Квадрат и звезду в одной программе, на одном графическом поле, но с разными экземплярами класса Turtle.
- Восьмиконечную звезду (угол поворота 135 градусов).
- Фигуру из анимации в начале страницы.
Решения
import turtle
square = turtle.Turtle()
for i in range(4):
square.forward(100)
square.right(90)
starf = turtle.Turtle()
for i in range(5):
starf.forward(100)
starf.right(144)
turtle.exitonclick()
import turtle
star = turtle.Turtle()
star.
hideturtle()
for i in range(8):
star.forward(100)
star.right(135)
turtle.exitonclick()
import turtle
nineang = turtle.Turtle()
for i in range(9):
nineang.forward(100)
nineang.left(140)
nineang.forward(100)
nineang.right(100)
turtle.
exitonclick()
Изменяем параметры во время движения
При отрисовке простых фигур черепашка возвращалась в исходную точку, и программа останавливалась, ожидая, когда будет закрыто окно.
Если в цикле продолжить рисовать по прежним инструкциям, фигура будет нарисована заново по уже нарисованным контурам.
А если ввести дополнительный угол поворота?
import turtle
square = turtle.Turtle()
square.shape(«turtle»)
square.color('red', 'green')
square.begin_fill()
for j in range(3):
square.left(20)
for i in range(4):
square.forward(100)
square.left(90)
square.end_fill()
turtle.exitonclick()
Мы также добавили:
- color('red', 'green') определяет цвет линии и цвет заполнения. Черепашка теперь зеленая!
- begin_fill() и end_fill() обозначают начало и конец заполнения
Больше программирования!
Напишем обобщенную программу рисования выпуклых равносторонних многоугольников. num_sides – количество граней, side_length – длина грани, angle – угол поворота.
import turtle
polygon = turtle.Turtle()
num_sides = 6
side_length = 100
angle = 360.0 / num_sides
for i in range(num_sides):
polygon.forward(side_length)
polygon.right(angle)
turtle.exitonclick()
Что будет, если на каждом шаге увеличивать длину пути? В первый день 10 шагов, во второй – 20, далее 30, 40 и так до 200:
import turtle
spiral = turtle.Turtle()
for i in range(20):
spiral.forward(i * 10)
spiral.right(144)
turtle.exitonclick()
Координаты на плоскости
Положение на плоскости определяется двумя числами, x и y:
Черепашку в программе можно перемещать функцией goto(x, y). x и y – числа, или переменные. goto(0, 0) переместит черепашку в начало координат.
import turtle
spiral = turtle.Turtle()
for i in range(20):
spiral.fd(i * 10)
spiral.rt(144)
spiral.goto(0,0)
turtle.exitonclick()
Вместо звезды-спирали мы получили 5 линий, расходящихся из точки начала координат.
Круг и точка
Не хватает плавных изгибов? На помощь приходят функции dot() и circle():
import turtle
turtle.title(«Turtle Drawing»)
circle = turtle.Turtle()
circle.shape(«turtle»)
circle.pensize(5)
circle.pencolor(«cyan»)
circle.dot(20)
circle.penup()
circle.goto(0, -100)
circle.pendown()
circle.circle(100)
turtle.exitonclick()
Дополнительно мы:
- изменили заголовок окна функцией title(),
- установили толщину линии – pensize(),
- установили цвет линии – pencolor(),
- Подняли черепашку перед перемещением – penup() и опустили после – pendown().
Самостоятельно:
- Используя код из примеров и функцию goto(), нарисовать галерею из 5 или более многоугольников на одном поле. Использовать экземпляр класса turtle.Turtle().
- Нарисованные многоугольники закрасить разными цветами. Пробуйте стандартные цвета или их шестнадцатеричное представление. Не забудьте кавычки вокруг названия или кода цвета!
Решения
Несколько закрашенных фигур
- У нас есть два варианта нарисовать несколько фигур: используя отдельные классы и не используя их. Рассмотрим оба варианта.
- Без классов: import turtle
turtle.hideturtle()
turtle.speed(10)turtle.color('red')
turtle.begin_fill()
for i in range(4):
turtle.forward(100)
turtle.right(90)
turtle.end_fill()turtle.penup()
turtle.goto(200, 200)
turtle.pendown()turtle.color('green')
turtle.begin_fill()
for i in range(5):
turtle.forward(100)
turtle.rt(144)
turtle.end_fill()turtle.penup()
turtle.goto(-200, -200)
turtle.pendown()turtle.color('blue')
turtle.begin_fill()
for i in range(8):
turtle.forward(100)
turtle.right(135)
turtle.end_fill()turtle.penup()
turtle.goto(200, -200)
turtle.pendown()turtle.color('cyan')
turtle.begin_fill()
for i in range(3):
turtle.forward(100)
turtle.lt(120)
turtle.end_fill()turtle.penup()
turtle.goto(-200, 200)
turtle.pendown()turtle.color('magenta')
turtle.begin_fill()
for i in range(9):
turtle.forward(30)
turtle.right(140)
turtle.forward(30)
turtle.left(100)
turtle.end_fill()turtle.exitonclick()
- Получается довольно многословно. С классами (начало): import turtle
square = turtle.Turtle()
square.hideturtle()
square.color('red')
square.speed(10)
square.begin_fill()
for i in range(4):
square.forward(100)
square.right(90)
square.end_fill()
square.penup() - Так еще многословнее. Зачем нам понадобилось писать для каждой фигуры отдельный класс? Для того, чтобы подготовиться к написанию программы с помощью функций, которые помогут обобщить и сократить наш код. Создадим функции, используя написанную ранее обобщенную программу рисования выпуклых равносторонних многоугольников. Функция prepare() делает все приготовления для рисования: переходит в нужную точку холста, устанавливает нужный цвет и дает команду заполнять цветом. У функции три входных параметра: координаты по осям X, Y и кодовое слово цвета. Функция draw_polygon() – наш старый знакомый, так мы рисуем выпуклый многоугольник. У функции два входных параметра: количество граней и длина грани. import turtle
def prepare(x, y, color):
turtle.penup()
turtle.goto(x, y)
turtle.pendown()
turtle.color(color)
turtle.begin_fill()def draw_polygon(num_sides, side_length):
angle = 360.0 / num_sides
for i in range(num_sides):
turtle.forward(side_length)
turtle.right(angle)turtle.hideturtle()
turtle.speed(10)prepare(0, 0, 'red')
draw_polygon(3, 100)
turtle.end_fill()prepare(200, 200, 'green')
draw_polygon(4, 100)
turtle.end_fill()prepare(-200, -200, 'blue')
draw_polygon(5, 100)
turtle.end_fill()prepare(200, -200, 'cyan')
draw_polygon(6, 100)
turtle.end_fill()prepare(-200, 200, 'magenta')
draw_polygon(7, 100)
turtle.end_fill()turtle.exitonclick()
- Получилось существенно сократить программу, и она стала более читаемой. Но повторяющиеся действия остались. Значит, есть еще работа для программиста! Будем рисовать все 5 фигур в цикле. Для этого все параметры соберем в списки, а внутри цикла будем брать значение параметра по индексу (номеру минус 1) в списке. Теперь всего 22 строки кода: import turtle
def prepare(x, y, color):
turtle.penup()
turtle.goto(x, y)
turtle.pendown()
turtle.color(color)
turtle.begin_fill()def draw_polygon(num_sides, side_length):
angle = 360.0 / num_sides
for i in range(num_sides):
turtle.forward(side_length)
turtle.right(angle)
turtle.end_fill()turtle.hideturtle()
turtle.speed(10)colors = ['red', 'green', 'blue', 'cyan', 'magenta']
xcoords = [0, 200, -200, 200, -200]
ycoords = [0, 200, -200, -200, 200]
for i in range(5):
prepare(xcoords[i], ycoords[i], colors[i])
draw_polygon(i+3, 100)turtle.exitonclick()
- Получились фигуры разного размера. Самостоятельно: Задать переменной внутри цикла длину грани так, чтобы фигуры казались (или являлись) равновеликими.
Делаем фигуры равновеликими
Площадь квадрата со стороной 100 пикселей – 10 000 квадратных пикселей.
Вычислим площади всех фигур со стороной 100 от треугольника до 7-угольника.
Формула площади правильного многоугольника содержит тангенс, поэтому «поверим на слово» результату, зависимости количество углов (вершин) – площадь:
- 3 – 4330.13
- 4 – 10000
- 5 – 17204.77
- 6 – 25980.76
- 7 – 36339.12
Изобразим ее на графике:
Получается, что площадь 7-угольника в 36339.12 / 4330.13 = 8.4 раза больше, чем площадь треугольника! Это очень заметно на рисунке:
Чтобы фигуры стали равновеликими, надо сделать длину грани вместо константы 100 – переменной, которая зависит от количества углов.
Как: приведем все площади к 10000. Для треугольника площадь увеличится на 10000 / 4330.13 = 2.31 раза. Для 7-угольника – уменьшится в 36339.12 / 10000 = 3.63 раз.
Значит, стороны должны измениться в 1.52 и 0.52 раз соответственно, то есть, до 152 и 32.7 пикселей (снова «верим на слово»).
Эту зависимость можно нащупать «на глаз», в чем и заключалось задание.
Наша программа без труда масштабируется до большего количества фигур:
Программа, в которой вычисляются точные значения:
import turtle
from math import tan, sqrt, pi
def prepare(x, y, color):
turtle.penup()
turtle.goto(x, y)
turtle.pendown()
turtle.color(color)
turtle.begin_fill()
def draw_polygon(num_sides, side_length):
angle = 360.0 / num_sides
for i in range(num_sides):
turtle.forward(side_length)
turtle.right(angle)
turtle.end_fill()
def calc_s(num_sides, side_length):
return num_sides * side_length ** 2 / (4 * tan(pi/num_sides))
def calc_side(square):
return sqrt(4 * square * tan(pi/num_sides) / num_sides)
turtle.hideturtle()
turtle.speed(10)
colors = ['red', 'green', 'blue', 'cyan', 'magenta', 'black', 'yellow', 'pink', 'brown']
xcoords = [0, 150, -150, 150, -150, 270, -270, 270, -270]
ycoords = [0, 150, -150, -150, 150, 270, -270, -270, 270]
squares = []
numsides = []
for i in range(9):
num_sides = i + 3
square = round(calc_s(num_sides, 100), 2)
side_length = round(calc_side(10000), 3)
squares.append(square)
numsides.append(num_sides)
print(«Углов:», num_sides, «была площадь:», square, «стала длина грани:», side_length,
«изменение в», round(side_length/100, 2), «раз»)
prepare(xcoords[i], ycoords[i], colors[i])
draw_polygon(num_sides, side_length)
turtle.exitonclick()
print(«Список количество углов:», numsides, end=»»)
print(«Список площади:», squares)
Текстовый вывод:
Углов: 3 была площадь: 4330.13 стала длина грани: 151.967 изменение в 1.52 раз
Углов: 4 была площадь: 10000.0 стала длина грани: 100.0 изменение в 1.0 раз
Углов: 5 была площадь: 17204.77 стала длина грани: 76.239 изменение в 0.76 раз
Углов: 6 была площадь: 25980.76 стала длина грани: 62.04 изменение в 0.62 раз
Углов: 7 была площадь: 36339.12 стала длина грани: 52.458 изменение в 0.52 раз
Углов: 8 была площадь: 48284.27 стала длина грани: 45.509 изменение в 0.46 раз
Углов: 9 была площадь: 61818.24 стала длина грани: 40.22 изменение в 0.4 раз
Углов: 10 была площадь: 76942.09 стала длина грани: 36.051 изменение в 0.36 раз
Углов: 11 была площадь: 93656.4 стала длина грани: 32.676 изменение в 0.33 раз
Список количество углов: [3, 4, 5, 6, 7, 8, 9, 10, 11]
Список площади: [4330.13, 10000.0, 17204.77, 25980.76, 36339.12, 48284.27, 61818.24, 76942.09, 93656.4]
Как построить график (если кто захочет):
- Поставить Matplotlib, набрав в командной строке pip install matplotlib
- Запустить программу import matplotlib.pyplot as plt
numsides = [3, 4, 5, 6, 7, 8, 9, 10, 11]
squares = [4330.13, 10000.0, 17204.77, 25980.76, 36339.12, 48284.27, 61818.24, 76942.09, 93656.4]
plt.plot(numsides, squares, 'or—')
plt.xlabel('Количество углов')
plt.ylabel('Площадь')
plt.show()
Другие полезные функции:
- turtle.setup(800, 400) устанавливает размеры окна в 800 на 400 пикселей
- turtle.setworldcoordinates(0, 0, 800, 400) устанавливает начало координат в точку 800, 400
- turtle.tracer(0, 0) отключает анимацию
- setpos(x, y) устанавливает черепашку (курсор) в позицию с координатами (x, y)
- seth(x) устанавливает направление в градусах. 0 – горизонтально направо (на восток), 90 – вверх (на север) и так далее
- hideturtle() скрывает черепашку (или стрелку, курсор)
- speed(x) изменяет скорость рисования. Например, speed(11) – почти моментальная отрисовка простых фигур
- clear() очищает холст от нарисованного
- reset() очищает холст и возвращает курсор в начало координат
Пример двух рисунков – экземпляров класса Turtle() – на одном полотне
import turtle
turtle.title(«Turtle Circles»)
circ = turtle.Turtle()
circ.pencolor(«purple»)
circ.fillcolor(«orange»)
circ.shape(«circle»)
circ.pensize(5)
circ.speed(10)
circ.fd(150)
circ.begin_fill()
circ.circle(90)
circ.end_fill()
n = 10
t = turtle.Turtle()
while n
Команды передвижения/рисования пером по холсту
В материале представлены команды, отвечающие за рисование, передвижение, изменение направления, а так же настройка измерения величины угла поворота (градусы/радианы) в модуле turtle.
При рисовании можно использовать как функции модуля, так и одноименные методы экземпляра пера/холста:
>>> import turtle
# функция модуля
>>> turtle.fd(150)
# создание экземпляра пера
>>> pen = turtle.Turtle()
>>> pen.lt(90)
>>> pen.fd(150)
Содержание:
- Движение пера/карандаша:
- Скорость перемещения пера/карандаша по холсту:
- turtle.speed() устанавливает.возвращает скорость передвижения пера,
- Поворот пера/карандаша:
- Настройка угла поворота пера
- Ориентация пера на холсте:
- Отмена действий:
- turtle.undo() отменяет действие пера.
Движение пера/карандаша
turtle.forward(distance),turtle.fd(distance):
Методы turtle.forward и turtle.fd() передвигают перо черепахи вперед на указанное расстояние distance и в том направлении, в котором она движется.
Аргумент distance принимает число int или float.
>>> turtle.position()
# (0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
# (25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
# (-50.00,0.00)
turtle.back(distance),turtle.bk(distance):
Методы turtle.back(distance) и turtle.backward() передвигают перо черепахи назад на расстояние distance, в противоположном направлении, в котором она движется. Этот метод не меняет угол/направление черепахи.
Аргумент distance принимает число int или float.
>>> turtle.position()
# (0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
# (-30.00,0.00)
Скорость перемещения пера/карандаша по холсту
turtle.speed(speed=None):
Метод turtle.speed() задает скорость перемещения пера черепахи по холсту целым числом в диапазоне 0 — 10 или строкой, означающей скорость.
Если аргумент не указан, то возвращает текущую скорость.
Если число speed больше 10 или меньше 0,5, то скорость устанавливается равной 0. Строки скорости сопоставляются со значениями скорости следующим образом:
- 'fastest': 0
- 'fast': 10
- 'normal': 6
- 'slow': 3
- 'slowest': 1
>>> turtle.speed()
# 3
>>> turtle.speed('normal')
>>> turtle.speed()
# 6
>>> turtle.speed(9)
>>> turtle.speed()
# 9
Поворот пера/карандаша
turtle.right(angle),turtle.rt(angle):
Методы turtle.right() и turtle.rt() поворачивают черепаху вправо на единицу измерения угла angle.
Единицы измерения угла по умолчанию — градусы, но их можно задать с помощью функций turtle.degrees() и turtle.radians(). Ориентация угла зависит от режима turtle.mode() пера черепахи.
Аргумент angle принимает число int или float.
>>> turtle.heading()
# 22.0
>>> turtle.right(45)
>>> turtle.heading()
# 337.0
turtle.left(angle),turtle.lt(angle):
Методы turtle.left() и turtle.lt() поворачивают черепаху влево на единицу измерения угла angle.
Аргумент angle принимает число int или float.
>>> turtle.heading()
# 22.0
>>> turtle.left(45)
>>> turtle.heading()
# 67.0
Настройка измерения угла поворота пера
turtle.degrees(fullcircle=360.0):
Метод turtle.degrees() устанавливает единицы измерения угла, т. е. задает количество градусов для полного круга. Значение по умолчанию это 360 градусов.
Аргумент fullcircle — целое число int.
>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
# 90.0
Пример изменения единицы измерения угла в градиан (который равен 1/100-й части прямого угла).
>>> turtle.degrees(400.0)
>>> turtle.heading()
# 100.0
>>> turtle.degrees(360)
>>> turtle.heading()
# 90.0
turtle.radians():
Метод turtle.radians() устанавливает единицы измерения угла в радианы. Эквивалентно градусам как 2 * math.pi.
>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
# 90.0
>>> turtle.radians()
>>> turtle.heading()
# 1.5707963267948966
turtle.setheading(to_angle),turtle.seth(to_angle):
Методы turtle.setheading() и turtle.seth() устанавливает направление движения (ориентацию) пера черепахи в значение to_angle.
Аргумент to_angle — число (int или float).
Вот некоторые общие направления в градусах:
| standard mode | logo mode |
| 0 — east | 0 — north |
| 90 — north | 90 — east |
| 180 — west | 180 — south |
| 270 — south | 270 — west |
>>> turtle.setheading(90)
>>> turtle.heading()
# 90.0
turtle.home():
Метод turtle.home() перемещает черепаху в начало координат (координаты (0,0)) и устанавливает его заголовок в начальную ориентацию, которая зависит от turtle.mode().
>>> turtle.heading()
# 90.0
>>> turtle.position()
# (0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
# (0.00,0.00)
>>> turtle.heading()
# 0.0
Отмена действий
turtle.undo():
Метод turtle.undo() отменяет (можно повторять многократно) последнее действие(я) черепахи.
Количество доступных действий отмены определяется размером буфера отмены.
>>> for i in range(4):
… turtle.fd(50); … turtle.lt(80)
…
>>> for i in range(8):
… turtle.undo()
Загрузка...
