Как написать черепашку - Правописание и грамматика

Черепашья
графика,
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()
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().
Нарисованные многоугольники закрасить разными цветами. Пробуйте стандартные цвета или их шестнадцатеричное представление.
Не забудьте кавычки вокруг названия или кода цвета!

Решения

Делаем фигуры равновеликими

Площадь квадрата со стороной 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 <= 50:
    t.circle(n)
    n += 10

turtle.exitonclick()

Что произошло:

Задали название окна,
создали экземпляр класса Turtle под именем circ. Все изменения сохраняются для класса circ;
цвет линии и заполняющий цвет,
форму и размер курсора,
установили 10-ю скорость
продвинулись на 150 пикселей вперед от старта,
начали заполнять фигуру цветом,
нарисовали круг
закончили заполнять цветом,

Затем:

Объявили переменную n и присвоили ей значение 10,
создали новый экземпляр класса Turtle под именем t. У него нет настроек экземпляра класса circ!
В цикле while: пока переменная n меньше или равна 50, рисовать круги радиусом n;
после нарисованного круга увеличить переменную n на 10.
Алгоритм рисования кругов прекратит рисовать круги после 4-го круга.

Итог: функции и классы на примере turtle

Функция – фрагмент программного кода, к которому можно обратиться по имени. Иногда функции бывают безымянными.
У функции есть входные и выходные параметры. Функция fd(150) – фрагмент программного кода, который двигает курсор вперед на заданное во входном значении количество пикселей (150). Выходного значения у функции fd() нет.
Когда функцию надо выполнить, после ее названия пишут круглые скобки. fd – просто название, ничего не происходит. fd(100) – функция выполняется с входным параметром 100. Обычно названия функций пишут с маленькой буквы.
Класс – программный шаблон для создания объектов, заготовка для чего-то, имеющего собственное состояние. Мы можем нарисовать прямоугольник и назвать его кнопкой, но это еще не кнопка, потому что у нее нет собственных свойств и поведения. Прямоугольник надо научить быть самостоятельной, отличной от других, кнопкой.
Turtle – класс, его имя пишется с большой буквы. через оператор присваивания = мы создаем экземпляр класса: circ = turtle.Turtle(). Turtle – класс (шаблон, трафарет, заготовка), circ – его экземпляр (рисунок, набор уникальных цветов, штрихов и свойств). На картинке выше видно, что экземпляр класса circ богат установленными свойствами, а экземпляр t обладает свойствами по умолчанию: тонкая черная линия, треугольный курсор.
Программирование с использованием классов и их экземпляров будем называть объектно-ориентированным программированием, ООП. объектно-ориентированный подход необходим при построении графического интерфейса пользователя, GUI.

Графический интерфейс средствами библиотеки turtle.

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

import turtle

wndow = turtle.Screen()
wndow.title("Screen & Button")
wndow.setup(500, 500)

btn1 = turtle.Turtle()
btn1.hideturtle()
for i in range(2):
    btn1.fd(80)
    btn1.left(90)
    btn1.fd(30)
    btn1.left(90)
btn1.penup()
btn1.goto(11,7)
btn1.write("Push me", font=("Arial", 12, "normal"))

def btnclick(x, y):
    if 0<x<80 and 0<y<30:
        print("Кнопка нажата!")
        btn1.clear()
        ball = turtle.Turtle()
        turtle.fillcolor("orange")
        turtle.pencolor("purple")
        turtle.shape("circle")

turtle.listen()
turtle.onscreenclick(btnclick, 1)
turtle.done()

Что произошло:

Задали название и размеры (500 на 500 пикселей) окна,
Создали экземпляр класса btn1 и спрятали курсор (черепашку),
Нарисовали прямоугольник 80 на 30;
подняли перо и перешли на координаты (11, 7);
написали Push me шрифтом Arial 12-го размера, нормальное начертание. Попробуйте вместо normal ключевые слова bold (полужирный), italic (наклонный);

Задаем поведение кнопки:

Функции turtle.listen() и turtle.onscreenclick() будут слушать (listen) и реагировать на клик по экрану (onscreenclick). Реакцией будет запуск функции btnclick(x, y)
Напишем btnclick(x, y). У нее 2 входных параметра – координаты точки, куда мы кликнули. Наша задача: если клик был по кнопке, спрятать ее и показать оранжевый круг
Мы помним: кнопка 80 на 30 пикселей от точки (0, 0). Значит, мы попали по кнопке, если x между 0 и 80 и y между 0 и 30. Условие попадания по кнопке: if 0<x<80 and 0<y<30:
1) Убираем кнопку: btn1.clear(), 2) создаем экземпляр класса ball = turtle.Turtle(), 3) устанавливаем ему нужные свойства.

Самостоятельно:

Нарисовать вторую кнопку (не изменяя первую!), сделать обработчик нажатия: при клике программа завершается, выполняется функция exit()
При нажатии на первую кнопку появляется случайная фигура: при рисовании фигуры использовать random:
```
from random import randrange
print(randrange(30, 201)) # случайное целое число от 30 до 200
```

Уточнения

Чтобы окно не закрывалось сразу, мы использовали turtle.exitonclick().
Теперь, когда клик обрабатывается функцией, пишем в конце turtle.done().
функция exit() самостоятельная, это не команда turtle. Писать turtle.exit() неверно.
Случайная фигура – это любая фигура, при рисовании которой используются случайные числа. Например:
```
from random import randrange
circle = turtle.Turtle()
circle.circle(randrange(36, 91))
```
Но есть и второй вариант: случайное число будет индексом списка и укажет на одну из заранее подготовленных неслучайных фигур:
```
from random import randrange
figures = ['circle', 'rectangle', 'triangle']
choice = figures[randrange(0, 3)] # случайный индекс от 0 до 2 даст одно из трех слов списка
```
Таким приемом можно случайно выбирать цвета фигур. Функция choice делает тоже самое изящнее:
```
from random import randrange, choice
colors = ['red', 'green', 'blue']
color = colors[randrange(0, 3)]
another_color = choice(colors)
```

Управляем рисунком с клавиатуры

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

turtle.onkeypress(fun, key): вызывается функция fun при нажатии клавиши key
turtle.onkey(fun, key): вызывается функция fun при отпускании клавиши key

Клавиша задается строкой с ее названием. Например, ‘space’ – пробел, ‘Up’ (с заглавной буквы) – стрелка вверх.
Клавиши букв задаются заглавными, только если мы хотим нажать именно заглавную (с Shift или Caps Lock).

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

xcor() и ycor() выдают координаты по x и y как дробные числа
setx(x) и sety(y) устанавливают координаты. x и y – числа

Создадим экземпляр класса Turtle и выведем его координаты:

import turtle

circ = turtle.Turtle()
circ.shape("circle")
circ.color("orange")
circ.penup()
print(circ.xcor(), circ.ycor())

Получили вывод «0.0 0.0». Теперь напишем функцию up(), которая будет
запускаться при нажатии стрелки вверх и перемещать наш circ на 10 пикселей вверх:

import turtle

circ = turtle.Turtle()
circ.shape("circle")
circ.color("orange")
circ.penup()

def up():
    y = circ.ycor() + 10
    circ.sety(y)

turtle.listen()
turtle.onkeypress(up, 'Up')
turtle.done()

Очень похоже на нажатие мышкой! Функцию up() можно сократить до одной строчки:

def up(): circ.sety(circ.ycor() + 10)

Будет работать, но функции в одну строчку писать не принято. Для таких случаев используют анонимные функции: у них может
вовсе не быть имени. В Python в качестве анонимных функций
используются лямбда-выражения, мы их уже использовали для
сортировки. Так будет выглядеть лямбда-функция up:

up = lambda: circ.sety(circ.ycor() + 10)

Она используется у нас только в одном месте, внутри функкии turtle.onkeypress(). А почему бы не соединить их вместе? Так будет выглядеть наша программа в сокращенном виде:

import turtle

circ = turtle.Turtle()
circ.shape("circle")
circ.color("orange")
circ.penup()
turtle.listen()
turtle.onkeypress(lambda: circ.sety(circ.ycor() + 10), 'Up')
turtle.done()

Всего 8 строк, и функции действительно не понадобилось имени! Как видим, язык Python дает возможность писать разными стилями, и мы можем выбирать на свой вкус: писать развернуто и красиво (как писал
Гавриил Романович Державин) или кратко
(как Эрнест Хемингуэй).

Самостоятельно:

Добавить движение circ влево, вправо и вниз
Скорость движения (у нас пока 10 пикселей за раз) сделать переменной

Соединяем все вместе

У нас уже есть кнопка с текстом и обработчик клика мышкой. Соединим все в одну программу:

import turtle

wndow = turtle.Screen()
wndow.title("Circle game")
wndow.setup(500, 500)

btn1 = turtle.Turtle()
btn1.hideturtle()
for i in range(2):
    btn1.fd(80)
    btn1.left(90)
    btn1.fd(30)
    btn1.left(90)
btn1.penup()
btn1.goto(4, 5)
btn1.write("Start!", font=("Arial", 12, "normal"))

circ = turtle.Turtle()
circ.hideturtle()
circ.shape("circle")
circ.color("orange")

def btnclick(x, y):
    if 0<x<80 and 0<y<30:
        btn1.clear()
        circ.showturtle()
        circ.penup()

turtle.listen()
turtle.onscreenclick(btnclick, 1)
turtle.onkeypress(lambda: circ.sety(circ.ycor() + 10), 'Up')
turtle.done()

Есть стартовый экран, управляемый с клавиатуры персонаж… Добавим препятствие, и уже почти готова игра!

import turtle

wndow = turtle.Screen()
wndow.title("Circle game")
wndow.setup(500, 500)

btn1 = turtle.Turtle()
btn1.hideturtle()
for i in range(2):
    btn1.fd(80)
    btn1.left(90)
    btn1.fd(30)
    btn1.left(90)
btn1.penup()
btn1.goto(4, 5)
btn1.write("Start!", font=("Arial", 12, "normal"))

circ = turtle.Turtle()
circ.hideturtle()
circ.shape("circle")
circ.color("orange")

sq = turtle.Turtle()
sq.hideturtle()
sq.penup()
sq.setposition(-20, 70)

def btnclick(x, y):
  if 0<x<80 and 0<y<30:
      btn1.clear()
      circ.showturtle()
      circ.penup()
      sq.pendown()
      print("sq position:", sq.xcor(), sq.ycor())
      for i in range(4):
          sq.fd(40)
          sq.rt(90)

def up():
    y = circ.ycor() + 10
    circ.sety(y)
    if -20<circ.xcor()<20 and 30<circ.ycor()<70:
        circ.hideturtle()
        sq.clear()
        circ.write("Game over!", font=("Arial", 12, "bold"))

turtle.listen()
turtle.onscreenclick(btnclick, 1)
turtle.onkeypress(up, 'Up')
turtle.done()

Самостоятельно:

Нарисовать фигуры, которые надо обойти герою игры. Это может быть простой лабиринт!
Написать условное выражение (если координаты circ больше заданных величин), при котором наступает победа, и игра заканчивается. Это может быть выход из лабиринта!
В программе должно быть реализовано движение во все 4 стороны. Можно использовать стрелки, можно – клавиши WASD. Также можно реализовать движение по диагонали, когда за один ход изменяются обе координаты.

Подсказки

Игра с подсчетом ходов

import turtle

def prepare_fig(fig, x, y):
    fig.hideturtle()
    fig.penup()
    fig.setposition(x, y)
    fig.speed(13)

def draw_square(fig, color, side_length):
    fig.pendown()
    fig.fillcolor(color)
    fig.begin_fill()
    for i in range(4):
        fig.fd(side_length)
        fig.rt(90)
    fig.end_fill()

def message(text, color):
    circ.hideturtle()
    circ.goto(0, 0)
    circ.color(color)
    sq.clear()
    sq2.clear()
    print(moves)
    circ.write(text, font=("Arial", 12, "bold"))

def win_or_die(moves):
    if -20 < circ.xcor() < 40 and 10 < circ.ycor() < 70:
        message(GAME_OVER_MSG + str(moves), 'red')
    if -60 < circ.xcor() < -20 and 50 < circ.ycor() < 90:
        message(WIN_MSG + str(moves), 'green')

def movey(deltay):
    global moves
    y = circ.ycor() + deltay
    circ.sety(y)
    moves += 1
    win_or_die(moves)

def movex(deltax):
    global moves
    x = circ.xcor() + deltax
    circ.setx(x)
    moves += 1
    win_or_die(moves)

wndow = turtle.Screen()
wndow.title("Circle game")
wndow.setup(500, 500)

circ = turtle.Turtle()
circ.penup()
circ.shape("circle")
circ.color("orange")

sq = turtle.Turtle()
prepare_fig(sq, -20, 70)
draw_square(sq, 'red', 60)
sq2 = turtle.Turtle()
prepare_fig(sq2, -60, 90)
draw_square(sq2, 'green', 40)

moves = 0
GAME_OVER_MSG = 'Game over!nСделано шагов: '
WIN_MSG = 'Победа!nСделано шагов: '
STEP = 10

turtle.listen()
turtle.onkeypress(lambda: movey(STEP), 'Up')
turtle.onkeypress(lambda: movey(-STEP), 'Down')
turtle.onkeypress(lambda: movex(STEP), 'Right')
turtle.onkeypress(lambda: movex(-STEP), 'Left')
turtle.done()

Всего 61 строка кода!

Добавляем в программу классы.

Ссылки

Simple drawing with turtle
Turtle Graphics in Python
The Beginner’s Guide to Python Turtle
Turtle examples
Give Python turtle a rectangular shape for ping pong game

Источник

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

#Выведем сообщение Hello, world!
turtle.write('Hello, world!')

У команды write() есть несколько необязательных параметров. Указывать их следует, если необходимо поменять внешний вид или параметры отображения текста. Один из таких параметров move, указывающий будет ли двигаться Черепашка по мере рисования надписи. По умолчанию он имеет значение False. Если его изменить на True, то после вывода Черепашка окажется в конце текста.

#Выведем сообщение Hello, world!
turtle.write('Hello, world!', move = True)

Следующий параметр align — служит для выравнивания надписи относительно Черепашки. Может принимать значения right, center и left. По умолчанию равен значению right.

#Выведем сообщение Hello, world! по центру
turtle.write('Hello, world!', align = 'center')

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

#Выведем сообщение шрифтом Arial размером 12 пунктов обычным начертанием
turtle.write('Hello, world!', font = ('Arial', 12, 'normal'))

Так же в качестве начертания можно использовать: bold — полужирный, italic — курсив, или объединить их вместе. Тогда текст будет напечатан полужирным курсивом.

Для ввода текстовых данных существует команда textinput(). В качестве параметров указать два текстовых сообщения, первый для заголовка окна, второй для сообщения в диалоговом окне.

#Ввод текстового значения
text = turtle.textinput('Заголовок окна', 'Текст в диалоговом окне')

После нажатия на кнопку OK в переменную text попадет текст диалоговом окне. Если будет нажата кнопка Cancel (Отмена), то будет передано значение None.

Для ввода числового значения существует команда numinput(). Помимо заголовка окна и текста сообщения, можно передать значение по умолчанию, которое будет отображаться в поле ввода, минимальное принимаемое значение и максимально возможное.

#Ввод числового значения
didgit = turtle.numinput('Заголовок', 'Текст в окне', 100, minval = 10, maxval = 1000)

Если будет введено число меньше указанного минимального значения или больше указанного максимального, то будет выдано предупреждение и предложено повторить попытку. В случае, если будет нажата кнопка Cancel, то в переменную didgit будет передано значение None.

Важно, команды textinput() и numinput() поддерживаются только в 3.x версии Python, во 2.x версии их нет.

Источник

Сильное желание чему то научиться — это уже 50% успеха!

Дейл Карнеги

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

Окно программы

import turtle – Подключаем библиотеку
turtle.title (“Название окна”)
t=turtle.Turtle () – Создаем переменную t, через которую будет действовать черепашка
turtle.mainloop () — Данная строка вызывает функцию mainloop. Эта функция вызывает бесконечный цикл окна, поэтому окно будет ждать любого взаимодействия с пользователем, пока не будет закрыто.

Команды перемещения черепашки

forward (n) — Проползти вперед n шагов (пикселей).
backward (n) — Проползти назад n шагов (пикселей).
left (angle) — Повернуться налево на а градусов.
right (angle) — Повернуться направо на a градусов.
circle (r) — Нарисовать окружность радиуса |r|, центр которой находится слева от черепашки, если r>0 и справа, если r<0.
circle (r,a) — Нарисовать дугу радиуса r и градусной мерой a. Дуга рисуется против часовой стрелки, если r>0 и по часовой стрелке, если r<0.
goto (x,y) — Переместить черепашку в точку с координатами (x,y).

Команды рисования

down() — Опустить перо. После этой команды черепашка начнет оставлять след при любом своем передвижении.
up() — Поднять перо.
width(n) — Установить ширину следа черепашки в n пикселей.
сolor(s) — Цвет следа черепашки. Например, «red», «yellow», «green» и т.д.
fill() — Используется для рисования закрашенных областей. Начиная рисовать закрашенную область, дайте команду turtle.begin_fill(), а закончив рисование области — turtle.end_fill().

Прочие команды

reset () — Возврат черепашки в исходное состояние: очищается экран, сбрасываются все параметры, черепашка устанавливается в начало координат, глядя вправо.
seth(90) — Черепаху разворачиваем на север по оси ординат
сlear () — Очистка экрана.
write (s) — Вывести текстовую строку s в точке нахождения черепашки.
radians () — Установить меру измерения углов (во всех командах черепашки) в радианы.
degrees () — Установить меру измерения углов в градусы. Этот режим включен по умолчанию.
tracer (f) — Включить режим отладки (трассировки) программы черепашки, если значение f равно 1. По умолчанию режим отладки включен.

Пример. Два пересекающихся отрезка под прямым углом не параллельно осям координат

import turtle — Подключаем библиотеку Turtle
t=turtle.Turtle() — Создаем переменную
a=200 — Задаем длину линии
t.reset() — Сброс параметров, черепашка в центре
t.color(1,1,0) — Желтый цвет
t.width(5) — Толщина линии 5
t.left(9) — Поворот 9 градусов
t.forward(a) — Рисуем линию вперед 200
t.backward(a/2) — Назад 100
t.left(90) — Поворот 90 градусов
t.forward(a/2) — Вперед 100
t.backward(a) — Назад 200
turtle.mainloop() Вызываем бесконечный цикл окна

Упражнения

1. Нарисуйте на экране равносторонний треугольник. Нарисуйте желтый равносторонний треугольник.
2. Нарисуйте на экране 10 равносторонних треугольников в случайной позиции и со случайной стороной.
3. Нарисуйте на экране квадрат и множество из 25 квадратов, стороны которых больше предыдущих.
4. Нарисуйте квадрат, стороны которого не параллельны осям координат c диагоналями.
5. Нарисуйте спиральки (как на картинке).
6. Нарисуйте две касающиеся окружности.
7. Нарисуйте две пересекающиеся окружности.
8. Нарисуйте сами какую-нибудь цветную картинку (дом, дерево, рожицу, компьютер, …).

Добавить комментарий

Источник

Looking for some awesome python turtle codes or programs then you are at the right place today in this article I will share with you the best awesome python turtle codes so read this article till the end.

Turtle is a python graphics(GUI) library. With the turtle module you can draw cartoons, shapes and some cool designs. It is a great library for drawing things in python.

I will show you the basic and advanced python turtle codes but you don’t have to worry I will provide you with the python turtle codes to copy.

Awesome Python Turtle Codes

Now we are ready to see some amazing python turtle programs. There will be the code of each program and output of how the drawing will look like, you can copy the code of a program and test it in this online python compiler.

You need to have a basic foundation of python and turtle module to understand how this programs work if you don’t know about turtle refer here: Learn python turtle, so let’s start.

1. Python Turtle Code For Star


import turtle

turtle.color("yellow")
turtle.Screen().bgcolor("black")

turtle.width(12)

for i in range(5):
    turtle.forward(150)
    turtle.right(144)
    
turtle.done()

Above is the python program to draw a star using turtle. Drawing a star in python is one of the most basic program in turtle.

Output

2. Python Turtle Code For Circle


import turtle
  
t = turtle.Turtle()

turtle.Screen().bgcolor("#f9fafc")
t.color('blue')
t.width(12)
t.circle(50)

Drawing a circle in python turtle is another program which is very easy and simple to do.

Output

3. Python Turtle Code For Doraemon


from turtle import *


# Doraemon with Python Turtle
def ankle(x, y):
    penup()
    goto(x, y)
    pendown()


def eyes():
    fillcolor("#ffffff")
    begin_fill()

    tracer(False)
    a = 2.5
    for i in range(120):
        if 0 <= i < 30 or 60 <= i < 90:
            a -= 0.05
            lt(3)
            fd(a)
        else:
            a += 0.05
            lt(3)
            fd(a)
    tracer(True)
    end_fill()


def daari():
    ankle(-32, 135)
    seth(165)
    fd(60)

    ankle(-32, 125)
    seth(180)
    fd(60)

    ankle(-32, 115)
    seth(193)
    fd(60)

    ankle(37, 135)
    seth(15)
    fd(60)

    ankle(37, 125)
    seth(0)
    fd(60)

    ankle(37, 115)
    seth(-13)
    fd(60)


def mukh():
    ankle(5, 148)
    seth(270)
    fd(100)
    seth(0)
    circle(120, 50)
    seth(230)
    circle(-120, 100)


def scarf():
    fillcolor('#e70010')
    begin_fill()
    seth(0)
    fd(200)
    circle(-5, 90)
    fd(10)
    circle(-5, 90)
    fd(207)
    circle(-5, 90)
    fd(10)
    circle(-5, 90)
    end_fill()


def nose():
    ankle(-10, 158)
    seth(315)
    fillcolor('#e70010')
    begin_fill()
    circle(20)
    end_fill()


def black_eyes():
    seth(0)
    ankle(-20, 195)
    fillcolor('#000000')
    begin_fill()
    circle(13)
    end_fill()

    pensize(6)
    ankle(20, 205)
    seth(75)
    circle(-10, 150)
    pensize(3)

    ankle(-17, 200)
    seth(0)
    fillcolor('#ffffff')
    begin_fill()
    circle(5)
    end_fill()
    ankle(0, 0)


def face():
    fd(183)
    lt(45)
    fillcolor('#ffffff')
    begin_fill()
    circle(120, 100)
    seth(180)
    # print(pos())
    fd(121)
    pendown()
    seth(215)
    circle(120, 100)
    end_fill()
    ankle(63.56, 218.24)
    seth(90)
    eyes()
    seth(180)
    penup()
    fd(60)
    pendown()
    seth(90)
    eyes()
    penup()
    seth(180)
    fd(64)


def taauko():
    penup()
    circle(150, 40)
    pendown()
    fillcolor('#00a0de')
    begin_fill()
    circle(150, 280)
    end_fill()


def Doraemon():
    taauko()

    scarf()

    face()

    nose()

    mukh()

    daari()

    ankle(0, 0)

    seth(0)
    penup()
    circle(150, 50)
    pendown()
    seth(30)
    fd(40)
    seth(70)
    circle(-30, 270)

    fillcolor('#00a0de')
    begin_fill()

    seth(230)
    fd(80)
    seth(90)
    circle(1000, 1)
    seth(-89)
    circle(-1000, 10)

    # print(pos())

    seth(180)
    fd(70)
    seth(90)
    circle(30, 180)
    seth(180)
    fd(70)

    # print(pos())
    seth(100)
    circle(-1000, 9)

    seth(-86)
    circle(1000, 2)
    seth(230)
    fd(40)

    # print(pos())

    circle(-30, 230)
    seth(45)
    fd(81)
    seth(0)
    fd(203)
    circle(5, 90)
    fd(10)
    circle(5, 90)
    fd(7)
    seth(40)
    circle(150, 10)
    seth(30)
    fd(40)
    end_fill()

    seth(70)
    fillcolor('#ffffff')
    begin_fill()
    circle(-30)
    end_fill()

    ankle(103.74, -182.59)
    seth(0)
    fillcolor('#ffffff')
    begin_fill()
    fd(15)
    circle(-15, 180)
    fd(90)
    circle(-15, 180)
    fd(10)
    end_fill()

    ankle(-96.26, -182.59)
    seth(180)
    fillcolor('#ffffff')
    begin_fill()
    fd(15)
    circle(15, 180)
    fd(90)
    circle(15, 180)
    fd(10)
    end_fill()

    ankle(-133.97, -91.81)
    seth(50)
    fillcolor('#ffffff')
    begin_fill()
    circle(30)
    end_fill()
    # Doraemon with Python Turtle

    ankle(-103.42, 15.09)
    seth(0)
    fd(38)
    seth(230)
    begin_fill()
    circle(90, 260)
    end_fill()

    ankle(5, -40)
    seth(0)
    fd(70)
    seth(-90)
    circle(-70, 180)
    seth(0)
    fd(70)

    ankle(-103.42, 15.09)
    fd(90)
    seth(70)
    fillcolor('#ffd200')
    # print(pos())
    begin_fill()
    circle(-20)
    end_fill()
    seth(170)
    fillcolor('#ffd200')
    begin_fill()
    circle(-2, 180)
    seth(10)
    circle(-100, 22)
    circle(-2, 180)
    seth(180 - 10)
    circle(100, 22)
    end_fill()
    goto(-13.42, 15.09)
    seth(250)
    circle(20, 110)
    seth(90)
    fd(15)
    dot(10)
    ankle(0, -150)

    black_eyes()


if __name__ == '__main__':
    screensize(800, 600, "#f0f0f0")
    pensize(3)
    speed(9)
    Doraemon()
    ankle(100, -300)
    mainloop()

Above code will draw doraemon. As you can see from the below output it is exactly looking like doraemon. This is the power of turtle module.

Want a detailed tutorial on drawing doraemon using python visit here: Draw doraemon using python turtle.

Output

4. Python Turtle Code For Flower


import turtle
turtle.title('Sixteen Petals Flower')
turtle.setworldcoordinates(-2000,-2000,2000,2000)

def draw_flower(x,y,tilt,radius):
    turtle.up()
    turtle.goto(x,y)
    turtle.down()
    turtle.seth(tilt-45)
    turtle.circle(radius,90)
    turtle.left(90)
    turtle.circle(radius,90)

for tilt in range(0,360,30):
    draw_flower(0,0,tilt,1000)

Another awesome turtle program as you can see from the below output it draws a amazing beautiful rose flower.

Want more detailed tutorial on drawing flower in python turtle go here: Draw a flower using python turtle.

Output

5. Python Turtle Code For Pikachu


import turtle


def setup(x, y):
    turtle.setx(x)
    turtle.sety(y)
    print(x, y)


class Draw_Pikachu:

    def __init__(self):
        self.t = turtle.Turtle()
        t = self.t
        t.pensize(3)
        t.speed(9)
        t.ondrag(setup)

    def meme(self, x, y):
        self.t.penup()
        self.t.goto(x, y)
        self.t.pendown()

    def aankha1(self, x, y):
        self.meme(x, y)
        t = self.t
        t.seth(0)
        t.fillcolor('#333333')
        t.begin_fill()
        t.circle(22)
        t.end_fill()

        self.meme(x, y + 10)
        t.fillcolor('#000000')
        t.begin_fill()
        t.circle(10)
        t.end_fill()

        self.meme(x + 6, y + 22)
        t.fillcolor('#ffffff')
        t.begin_fill()
        t.circle(10)
        t.end_fill()

    def aankha2(self, x, y):
        self.meme(x, y)
        t = self.t
        t.seth(0)
        t.fillcolor('#333333')
        t.begin_fill()
        t.circle(22)
        t.end_fill()

        self.meme(x, y + 10)
        t.fillcolor('#000000')
        t.begin_fill()
        t.circle(10)
        t.end_fill()

        self.meme(x - 6, y + 22)
        t.fillcolor('#ffffff')
        t.begin_fill()
        t.circle(10)
        t.end_fill()

    def mukh(self, x, y):
        self.meme(x, y)
        t = self.t

        t.fillcolor('#88141D')
        t.begin_fill()
        #
        l1 = []
        l2 = []
        t.seth(190)
        a = 0.7
        for i in range(28):
            a += 0.1
            t.right(3)
            t.fd(a)
            l1.append(t.position())

        self.meme(x, y)

        t.seth(10)
        a = 0.7
        for i in range(28):
            a += 0.1
            t.left(3)
            t.fd(a)
            l2.append(t.position())

        #

        t.seth(10)
        t.circle(50, 15)
        t.left(180)
        t.circle(-50, 15)

        t.circle(-50, 40)
        t.seth(233)
        t.circle(-50, 55)
        t.left(180)
        t.circle(50, 12.1)
        t.end_fill()

        #
        self.meme(17, 54)
        t.fillcolor('#DD716F')
        t.begin_fill()
        t.seth(145)
        t.circle(40, 86)
        t.penup()
        for pos in reversed(l1[:20]):
            t.goto(pos[0], pos[1] + 1.5)
        for pos in l2[:20]:
            t.goto(pos[0], pos[1] + 1.5)
        t.pendown()
        t.end_fill()

        #
        self.meme(-17, 94)
        t.seth(8)
        t.fd(4)
        t.back(8)

    #
    def gaala1(self, x, y):
        turtle.tracer(False)
        t = self.t
        self.meme(x, y)
        t.seth(300)
        t.fillcolor('#DD4D28')
        t.begin_fill()
        a = 2.3
        for i in range(120):
            if 0 <= i < 30 or 60 <= i < 90:
                a -= 0.05
                t.lt(3)
                t.fd(a)
            else:
                a += 0.05
                t.lt(3)
                t.fd(a)
        t.end_fill()
        turtle.tracer(True)

    def gaala2(self, x, y):
        t = self.t
        turtle.tracer(False)
        self.meme(x, y)
        t.seth(60)
        t.fillcolor('#DD4D28')
        t.begin_fill()
        a = 2.3
        for i in range(120):
            if 0 <= i < 30 or 60 <= i < 90:
                a -= 0.05
                t.lt(3)
                t.fd(a)
            else:
                a += 0.05
                t.lt(3)
                t.fd(a)
        t.end_fill()
        turtle.tracer(True)

    def kaan1(self, x, y):
        t = self.t
        self.meme(x, y)
        t.fillcolor('#000000')
        t.begin_fill()
        t.seth(330)
        t.circle(100, 35)
        t.seth(219)
        t.circle(-300, 19)
        t.seth(110)
        t.circle(-30, 50)
        t.circle(-300, 10)
        t.end_fill()

    def kaan2(self, x, y):
        t = self.t
        self.meme(x, y)
        t.fillcolor('#000000')
        t.begin_fill()
        t.seth(300)
        t.circle(-100, 30)
        t.seth(35)
        t.circle(300, 15)
        t.circle(30, 50)
        t.seth(190)
        t.circle(300, 17)
        t.end_fill()

    def jiu(self):
        t = self.t

        t.fillcolor('#F6D02F')
        t.begin_fill()
        #
        t.penup()
        t.circle(130, 40)
        t.pendown()
        t.circle(100, 105)
        t.left(180)
        t.circle(-100, 5)

        #
        t.seth(20)
        t.circle(300, 30)
        t.circle(30, 50)
        t.seth(190)
        t.circle(300, 36)

        #
        t.seth(150)
        t.circle(150, 70)

        #
        t.seth(200)
        t.circle(300, 40)
        t.circle(30, 50)
        t.seth(20)
        t.circle(300, 35)
        # print(t.pos())

        #
        t.seth(240)
        t.circle(105, 95)
        t.left(180)
        t.circle(-105, 5)

        #
        t.seth(210)
        t.circle(500, 18)
        t.seth(200)
        t.fd(10)
        t.seth(280)
        t.fd(7)
        t.seth(210)
        t.fd(10)
        t.seth(300)
        t.circle(10, 80)
        t.seth(220)
        t.fd(10)
        t.seth(300)
        t.circle(10, 80)
        t.seth(240)
        t.fd(12)
        t.seth(0)
        t.fd(13)
        t.seth(240)
        t.circle(10, 70)
        t.seth(10)
        t.circle(10, 70)
        t.seth(10)
        t.circle(300, 18)

        t.seth(75)
        t.circle(500, 8)
        t.left(180)
        t.circle(-500, 15)
        t.seth(250)
        t.circle(100, 65)

        #
        t.seth(320)
        t.circle(100, 5)
        t.left(180)
        t.circle(-100, 5)
        t.seth(220)
        t.circle(200, 20)
        t.circle(20, 70)

        t.seth(60)
        t.circle(-100, 20)
        t.left(180)
        t.circle(100, 20)
        t.seth(300)
        t.circle(10, 70)

        t.seth(60)
        t.circle(-100, 20)
        t.left(180)
        t.circle(100, 20)
        t.seth(10)
        t.circle(100, 60)

        #
        t.seth(180)
        t.circle(-100, 10)
        t.left(180)
        t.circle(100, 10)
        t.seth(5)
        t.circle(100, 10)
        t.circle(-100, 40)
        t.circle(100, 35)
        t.left(180)
        t.circle(-100, 10)

        #
        t.seth(290)
        t.circle(100, 55)
        t.circle(10, 50)

        t.seth(120)
        t.circle(100, 20)
        t.left(180)
        t.circle(-100, 20)

        t.seth(0)
        t.circle(10, 50)

        t.seth(110)
        t.circle(100, 20)
        t.left(180)
        t.circle(-100, 20)

        t.seth(30)
        t.circle(20, 50)

        t.seth(100)
        t.circle(100, 40)

        #
        t.seth(200)
        t.circle(-100, 5)
        t.left(180)
        t.circle(100, 5)
        t.left(30)
        t.circle(100, 75)
        t.right(15)
        t.circle(-300, 21)
        t.left(180)
        t.circle(300, 3)

        #
        t.seth(43)
        t.circle(200, 60)

        t.right(10)
        t.fd(10)

        t.circle(5, 160)
        t.seth(90)
        t.circle(5, 160)
        t.seth(90)

        t.fd(10)
        t.seth(90)
        t.circle(5, 180)
        t.fd(10)

        t.left(180)
        t.left(20)
        t.fd(10)
        t.circle(5, 170)
        t.fd(10)
        t.seth(240)
        t.circle(50, 30)

        t.end_fill()
        self.meme(130, 125)
        t.seth(-20)
        t.fd(5)
        t.circle(-5, 160)
        t.fd(5)

        #
        self.meme(166, 130)
        t.seth(-90)
        t.fd(3)
        t.circle(-4, 180)
        t.fd(3)
        t.seth(-90)
        t.fd(3)
        t.circle(-4, 180)
        t.fd(3)

        #
        self.meme(168, 134)
        t.fillcolor('#F6D02F')
        t.begin_fill()
        t.seth(40)
        t.fd(200)
        t.seth(-80)
        t.fd(150)
        t.seth(210)
        t.fd(150)
        t.left(90)
        t.fd(100)
        t.right(95)
        t.fd(100)
        t.left(110)
        t.fd(70)
        t.right(110)
        t.fd(80)
        t.left(110)
        t.fd(30)
        t.right(110)
        t.fd(32)

        t.right(106)
        t.circle(100, 25)
        t.right(15)
        t.circle(-300, 2)
        ##############
        # print(t.pos())
        t.seth(30)
        t.fd(40)
        t.left(100)
        t.fd(70)
        t.right(100)
        t.fd(80)
        t.left(100)
        t.fd(46)
        t.seth(66)
        t.circle(200, 38)
        t.right(10)
        t.fd(10)
        t.end_fill()

        #
        t.fillcolor('#923E24')
        self.meme(126.82, -156.84)
        t.begin_fill()

        t.seth(30)
        t.fd(40)
        t.left(100)
        t.fd(40)
        t.pencolor('#923e24')
        t.seth(-30)
        t.fd(30)
        t.left(140)
        t.fd(20)
        t.right(150)
        t.fd(20)
        t.left(150)
        t.fd(20)
        t.right(150)
        t.fd(20)
        t.left(130)
        t.fd(18)
        t.pencolor('#000000')
        t.seth(-45)
        t.fd(67)
        t.right(110)
        t.fd(80)
        t.left(110)
        t.fd(30)
        t.right(110)
        t.fd(32)
        t.right(106)
        t.circle(100, 25)
        t.right(15)
        t.circle(-300, 2)
        t.end_fill()

        self.topi(-134.07, 147.81)
        self.mukh(-5, 25)
        self.gaala1(-126, 32)
        self.gaala2(107, 63)
        self.kaan1(-250, 100)
        self.kaan2(140, 270)
        self.aankha1(-85, 90)
        self.aankha2(50, 110)
        t.hideturtle()

    def topi(self, x, y):
        self.meme(x, y)
        t = self.t
        t.fillcolor('#CD0000')
        t.begin_fill()
        t.seth(200)
        t.circle(400, 7)
        t.left(180)
        t.circle(-400, 30)
        t.circle(30, 60)
        t.fd(50)
        t.circle(30, 45)
        t.fd(60)
        t.left(5)
        t.circle(30, 70)
        t.right(20)
        t.circle(200, 70)
        t.circle(30, 60)
        t.fd(70)
        # print(t.pos())
        t.right(35)
        t.fd(50)
        t.circle(8, 100)
        t.end_fill()
        self.meme(-168.47, 185.52)
        t.seth(36)
        t.circle(-270, 54)
        t.left(180)
        t.circle(270, 27)
        t.circle(-80, 98)

        t.fillcolor('#444444')
        t.begin_fill()
        t.left(180)
        t.circle(80, 197)
        t.left(58)
        t.circle(200, 45)
        t.end_fill()

        self.meme(-58, 270)
        t.pencolor('#228B22')
        t.dot(35)

        self.meme(-30, 280)
        t.fillcolor('#228B22')
        t.begin_fill()
        t.seth(100)
        t.circle(30, 180)
        t.seth(190)
        t.fd(15)
        t.seth(100)
        t.circle(-45, 180)
        t.right(90)
        t.fd(15)
        t.end_fill()
        t.pencolor('#000000')

    def start(self):
        self.jiu()


def main():
    print('Painting the Cartoon... ')
    turtle.screensize(800, 600)
    turtle.title('Cartoon')
    drawing = Draw_Pikachu()
    drawing.start()
    turtle.mainloop()


if __name__ == '__main__':
    main()

Pokemon one of the most popular anime cartoon show and pikachu is one of the most loved pokemon and we have drawn it in python as you can see from below output.

Want more detailed tutorial on drawing pikachu in python then refer here: Draw pikachu using python turtle.

Output

6. Python Turtle Code For Iron Man


import turtle

canvas1 = [[(-40, 120), (-70, 260), (-130, 230), (-170, 200), (-170, 100), (-160, 40), (-170, 10), (-150, -10), (-140, 10),
           (-40, -20), (0, -20)],
          [(0, -20), (40, -20), (140, 10), (150, -10), (170, 10), (160, 40), (170, 100), (170, 200), (130, 230), (70, 260),
           (40, 120), (0, 120)]]
canvas2 = [[(-40, -30), (-50, -40), (-100, -46), (-130, -40), (-176, 0), (-186, -30), (-186, -40), (-120, -170), (-110, -210),
           (-80, -230), (-64, -210), (0, -210)],
          [(0, -210), (64, -210), (80, -230), (110, -210), (120, -170), (186, -40), (186, -30), (176, 0), (130, -40),
           (100, -46), (50, -40), (40, -30), (0, -30)]]
canvas3 = [[(-60, -220), (-80, -240), (-110, -220), (-120, -250), (-90, -280), (-60, -260), (-30, -260), (-20, -250),
           (0, -250)],
          [(0, -250), (20, -250), (30, -260), (60, -260), (90, -280), (120, -250), (110, -220), (80, -240), (60, -220),
           (0, -220)]]

turtle.hideturtle()
turtle.bgcolor('#ba161e')  # Dark Red
turtle.setup(500, 600)
turtle.title("I AM IRONMAN")
canvas1Goto = (0, 120)
canvas2Goto = (0, -30)
canvas3Goto = (0, -220)
turtle.speed(2)


def logo(a, b):
    turtle.penup()
    turtle.goto(b)
    turtle.pendown()
    turtle.color('#fab104')  # Light Yellow
    turtle.begin_fill()

    for i in range(len(a[0])):
        x, y = a[0][i]
        turtle.goto(x, y)

    for i in range(len(a[1])):
        x, y = a[1][i]
        turtle.goto(x, y)
    turtle.end_fill()


logo(canvas1, canvas1Goto)
logo(canvas2, canvas2Goto)
logo(canvas3, canvas3Goto)
turtle.hideturtle()
turtle.done()

Iron Man one of the most loved superhero from marvel movies so to show some love we have this python program.

Want more detailed guide on drawing iron man in python refer here: Draw Iron man in python turtle.

Output

7. Python Turtle Code For Heart


import turtle
wn = turtle.Screen()
wn.setup(width=400, height=400)
red = turtle.Turtle()

def curve():
    for i in range(200):
        red.right(1)
        red.forward(1)

def heart():
    red.fillcolor('red')
    red.begin_fill()
    red.left(140)
    red.forward(113)
    curve()
    red.left(120)
    curve()
    red.forward(112)
    red.end_fill()

heart()
red.ht()
turtle.done()

Above is the python turtle code to draw heart. As you can see from below image it draws a beautiful heart.

Want more detailed tutorial on drawing a heart in python read this: Draw a heart using python.

Output

8. Python Turtle Code For Shinchan


from turtle import *

s=Screen()
s.screensize(700,1000)
speed(5)
def myPosition(x, y):
    penup()
    goto(x, y)
    pendown()

pensize(2)
def ankur():
    fillcolor('#ffec40')
    begin_fill()
    right(25)
    forward(20)
    right(45)
    forward(20)
    left(70)
    forward(90)
    left(95)
    forward(75)
    left(85)
    forward(175)
    left(85)
    forward(75)
    left(95)
    forward(90)
    left(85)
    forward(18)
    end_fill()

def leftLeg():
    myPosition(-39,-25)
    fillcolor("#ffd699")
    begin_fill()
    right(89)
    forward(25)
    right(90)
    forward(50)
    right(90)
    forward(20)
    right(85)
    forward(50)
    end_fill()

def leftSock():
    myPosition(-36,-78)
    fillcolor("#ffffff")
    begin_fill()
    right(90)
    circle(80,13)
    right(110)
    forward(22)
    right(85)
    forward(19)
    right(90)
    forward(21)
    end_fill()

def leftShoe():
    myPosition(-69,-112)
    fillcolor("#b5ae60")
    begin_fill()
    right(90)
    left(5)
    forward(56)
    left(105)
    forward(13)
    left(75)
    forward(20)
    right(90)
    forward(15)
    circle(10,15)
    left(80)
    forward(4)
    circle(10,15)
    left(40)
    circle(20,15)
    forward(10)
    right(45)
    forward(15)
    circle(25,25)
    end_fill()

def rightLeg():
    myPosition(60,-28)
    fillcolor("#ffd699")
    begin_fill()
    #right(90)
    left(128)
    forward(25)
    right(95)
    forward(55)
    right(90)
    forward(20)
    right(85)
    forward(55)
    end_fill()

def rightSock():
    myPosition(64,-79)
    fillcolor("#ffffff")
    begin_fill()
    right(90)
    circle(90,14)
    right(110)
    forward(23)
    right(90)
    forward(15)
    right(80)
    forward(21)
    end_fill()

def rightShoe():
    myPosition(64,-108)
    fillcolor("#b5ae60")
    begin_fill()
    right(100)
    forward(56)
    left(160)
    forward(25)
    right(68)
    forward(17)
    left(90)
    circle(18,15)
    forward(5)
    left(75)
    forward(11)
    right(85)
    forward(20)
    left(45)
    circle(10,30)
    left(25)
    forward(5)
    end_fill()

def myShirt():
    myPosition(-75,48)
    fillcolor("red")
    begin_fill()
    left(72)
    forward(185)
    left(87)
    forward(75)
    right(68)
    circle(20,8)
    circle(300,23)
    left(90)
    circle(35,17)
    right(38)
    circle(35,17)
    left(58)
    forward(75)
    right(12)
    forward(140)
    right(40)
    forward(93)
    left(120)
    circle(-20,65)
    left(75)
    forward(10)
    left(23)
    forward(88)
    #circle(-80,10)
    right(31)
    forward(87)
    right(180)
    forward(108)
    right(180)
    forward(104)
    circle(10,70)
    end_fill()

def myHead():
    myPosition(-20,295)
    left(20)
    pensize(2)
    fillcolor('#fcc6a0')
    begin_fill()
    right(90)
    forward(40)
    right(90)
    circle(50,80)
    left(10)
    circle(50,80)
    left(2)
    circle(200,50)

    left(48)
    forward(60)
    #left(20)
    circle(45,60)
    right(5)
    circle(100,85)
    end_fill()
    fillcolor('black')
    begin_fill()

    pensize(2)
    right(170)
    circle(-100,165)
    right(78)
    forward(26)
    right(87)
    forward(55)
    circle(45,60)
    right(5)
    circle(100,85)
    end_fill()

    fillcolor('#fcc6a0')
    begin_fill()
    right(180)
    circle(-100,105)
    right(37)
    forward(49)
    pensize(2)
    left(130)
    forward(30)
    #right(5)
    circle(-10,70)
    right(50)
    #circle(10,10)
    forward(36)
    right(80)
    forward(50)
    pencolor('#fcc6a0')
    right(90)
    forward(30)

    end_fill()

def rightHand():
    #left(35)
    myPosition(197,209)
    pencolor('black')
    fillcolor('#fcc6a0')
    begin_fill()
    right(45)
    forward(6)
    left(55)
    forward(20)
    circle(-5,70)
    right(100)
    forward(18)
    left(105)
    forward(18)
    circle(-5,70)
    right(100)
    forward(18)
    left(145)
    forward(15)
    circle(-5,70)
    right(100)
    forward(18)

    left(150)
    forward(13)
    circle(-5,70)
    right(100)
    forward(15)

    left(150)
    forward(10)
    circle(-5,70)
    right(100)
    forward(12)
    circle(60,10)
    left(45)
    forward(6)
    right(90)
    forward(10)
    end_fill()

def leftHand():
    myPosition(-94,242)
    fillcolor('#fcc6a0')
    begin_fill()
    right(10)
    forward(6)
    left(90)
    penup()
    forward(12)
    pendown()
    left(90)
    forward(8)
    left(90)
    forward(12)
    end_fill()

def myBis():
    myPosition(-103,291)
    right(90)
    fillcolor('#02d302')
    begin_fill()
    right(90)
    forward(55)
    left(80)
    forward(12)
    left(10)
    forward(17)
    left(10)
    forward(12)
    left(80)
    forward(55)
    left(80)
    forward(12)
    left(10)
    forward(17)
    left(10)
    forward(12)
    left(80)
    left(80)
    forward(12)
    left(10)
    forward(17)
    left(10)
    forward(12)
    end_fill()
    penup()
    right(100)
    forward(20)
    right(90)
    forward(14)
    pendown()
    pencolor('#9c5e4a')
    fillcolor('#9c5e4a')
    begin_fill()
    for i in range(5):
        forward(15)
        right(144)
    end_fill()
    penup()
    forward(27)
    left(90)
    forward(16)
    left(90)
    forward(7)
    pendown()
    fillcolor('#9c5e4a')
    begin_fill()
    for i in range(5):
        forward(10)
        right(144)
    end_fill()
    penup()
    forward(20)
    right(90)
    forward(5)
    pendown()
    fillcolor('#9c5e4a')
    begin_fill()
    for i in range(5):
        forward(10)
        right(144)
    end_fill()
    penup()
    right(180)
    forward(6)
    pendown()
    fillcolor('#9c5e4a')
    begin_fill()
    for i in range(5):
        forward(10)
        right(144)
    end_fill()

def leftHand2():
    myPosition(-112,284)
    pencolor('black')
    fillcolor('#fcc6a0')
    begin_fill()
    right(180)
    forward(31)
    left(90)
    for i in range(2):
        circle(4,90)
        #circle(4//2,45)
    for i in range(3):
        right(180)
        for i in range(2):
            circle(4,90)
    end_fill()

def myMouth():
    myPosition(-25,200)
    left(65)
    fillcolor('#77332e')
    begin_fill()
    #circle(20)
    #forward(20)
    for i in range(2):
        circle(25,90)
        circle(25//2,90)
    end_fill()

def myEyebrow(x,y):
    myPosition(x,y)
    pensize(18)
    right(150)
    forward(25)
    right(90)
    for i in range(1):
        right(45)
        dot(15)
    left(55)
    forward(25)
    for i in range(1):
        right(45)
        dot(15)

def myEyelid(x,y):
    myPosition(x,y)
    pensize(2)
    left(170)
    circle(-23,180)

def myallEyes1(x,y):
    myPosition(x,y)
    right(90)
    fillcolor('#000000')
    begin_fill()
    circle(18)
    end_fill()
    left(90)
    penup()
    forward(19)
    right(90)
    forward(7)
    pendown()
    fillcolor('#ffffff')
    begin_fill()
    left(90)
    circle(9)
    end_fill()

def myallEyes2(x,y):
    myPosition(x,y)
    right(90)
    fillcolor('#000000')
    begin_fill()
    circle(18)
    end_fill()
    left(90)
    penup()
    forward(19)
    right(90)
    forward(8)
    pendown()
    fillcolor('#ffffff')
    begin_fill()
    left(90)
    circle(9)
    end_fill()

def myRobot():
    myPosition(155,-105)
    left(93)
    color('red')
    pensize(7)

    begin_fill()
    forward(50)
    left(90)
    forward(50)
    left(90)
    forward(50)
    left(90)
    forward(50)
    left(90)
    end_fill()


    color('white')
    penup()
    left(90)
    forward(30)
    right(90)
    forward(12)
    pendown()
    pensize(3)
    circle(5)
    penup()
    forward(25)
    pendown()
    circle(5)

    penup()
    right(90)
    forward(20)
    right(90)
    pendown()

    begin_fill()
    forward(23)
    right(90)
    forward(7)
    right(90)
    forward(23)
    right(90)
    forward(7)
    right(90)
    end_fill()

    penup()
    forward(25)
    right(90)
    forward(35)
    pendown()

    color('red')
    forward(30)
    penup()
    right(90)
    pendown()
    begin_fill()
    circle(5)
    end_fill()

def allLegs():
    leftLeg()
    leftSock()
    leftShoe()
    rightLeg()
    rightSock()
    rightShoe()
def allHands():
    rightHand()
    leftHand()
    myBis()
    leftHand2()
def allEyebrows():
    myEyebrow(-8,300)
    right(90)
    myEyebrow(72,300)
    myEyelid(-9,270)
    left(15)
    myEyelid(68,265)
def allEyes():
    myallEyes1(17,275)
    myallEyes2(95,270)
ankur()
allLegs()
myShirt()
myHead()
allHands()
myMouth()
allEyebrows()
allEyes()
myRobot()
ht()
done()

Shinchan another popular cartoon we love watching and above is the python turtle code to draw shinchan as you can see it is perfectly drawn.

Want a detailed guide on this program refer here: Draw shinchan using python turtle.

Output

9. Python Turtle Code For Spiral Circle


# Import the turtle library for
# drawing the required curve
import turtle as tt

# Set the background color as black,
# pensize as 2 and speed of drawing
# curve as 10(relative)
tt.Screen().bgcolor('black')
tt.pensize(2)
tt.speed(10)

# Iterate six times in total
for i in range(6):

	# Choose your color combination
	for color in ('red', 'magenta', 'blue',
				'cyan', 'green', 'white',
				'yellow'):
		tt.color(color)
		
		# Draw a circle of chosen size, 100 here
		tt.circle(100)
		
		# Move 10 pixels left to draw another circle
		tt.left(10)
	
	# Hide the cursor(or turtle) which drew the circle
	tt.hideturtle()
tt.done()

Above is the turtle code for a beautiful spiral circle which you can see from the below image. To draw this spiral design we write the code to draw circle in a loop with different colors.

Output

10. Python Turtle Code For Drawing Rainbow


import turtle
import colorsys

def draw_one_color_arc(x,y,r,pensize,color):
    turtle.up()
    turtle.goto(x+r,y)
    turtle.down()
    turtle.seth(90)
    turtle.pensize(pensize)
    turtle.pencolor(color)
    turtle.circle(r,180)


turtle.speed(0)
turtle.hideturtle()
turtle.bgcolor('light blue')
turtle.title('Rainbow In Python Turtle')
turtle.setup(700,700)
num_colors = 49

radius = 300
penwidth = 20*7/num_colors
hue = 0

for i in range(num_colors):
    (r,g,b) = colorsys.hsv_to_rgb(hue,1,1)
    draw_one_color_arc(0,-100,radius,penwidth,(r,g,b))
    radius -= (penwidth-1)
    hue += 0.9/num_colors

turtle.done()

This turtle program will draw a beautiful rainbow. As you can see from the below image.

Output

11. Python Turtle Code For Rainbow Spiral


import turtle
from turtle import *

turtle.title("rainbow spiral")
speed(15)
bgcolor("black")
r,g,b=255,0,0

for i in range(255*2):
    colormode(255)
    if i<255//3:
        g+=3
    elif i<255*2//3:
        r-=3
    elif i<255:
        b+=3
    elif i<255*4//3:
        g-=3
    elif i<255*5//3:
        r+=3
    else:
        b-=3
    fd(50+i)
    rt(91)
    pencolor(r,g,b)

done()

We just saw how to draw a rainbow now let’s see another beautiful rainbow but in spiral format. It is one of most beautiful drawing in turtle.

Output

Summary

These were all the awesome python turtle codes. I hope you found them amazing and helpful. Do share this article with your friends who might be interested in this. Want more drawing program visit turtle programs in python.

I will update more turtle codes in this article so to stay updated you can join our Telegram Channel for future blog updates.

Thanks for reading, Have a nice day 🙂

Источник

Общие сведения и подходы работы с модулем.

Модуль turtle — это расширенная реализация одноименного модуля из стандартного дистрибутива Python до версии Python 2.5.

Он сохраняет достоинства старого модуля turtle и почти на 100% совместим с ним. Это означает, чтобы дать возможность обучающемуся программисту использовать все команды, классы и методы в интерактивном режиме при использовании модуля из IDLE, запущенного с ключом -n.

Модуль turtle предоставляет графические примитивы черепахи как объектно-ориентированным, так и процедурно-ориентированным способами. Так как turtle для базовой графики использует tkinter, то необходима версия Python3, установленная с поддержкой Tk.

Объектно-ориентированный интерфейс использует по существу два + два класса:

Класс TurtleScreen определяет графические окна как площадку для рисования. Его конструктору требуется аргумент tkinter.Canvas или ScrolledCanvas. Его следует использовать, когда черепаха используется как часть какого-либо приложения.

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

Все методы TurtleScreen/Screen также существуют как функции, то есть как часть процедурно-ориентированного интерфейса.
RawTurtle определяет объекты Turtle, которые рисуются на TurtleScreen. Его конструктору требуется аргумент Canvas, ScrolledCanvas или TurtleScreen, чтобы объекты RawTurtle знали, где рисовать.

Производным от RawTurtle является подкласс Turtle, который использует экземпляр Screen, который создается автоматически, если еще не присутствует.

Все методы RawTurtle/Turtle также существуют как функции, то есть как часть процедурно-ориентированного интерфейса.

Процедурный интерфейс предоставляет функции, производные от методов классов Screen и Turtle. Названия у них такие же, как у соответствующих методов. Объект экрана screen всегда создается автоматически, когда вызывается функция, производная от метода Screen. Безымянный объект turtle всегда создается автоматически, когда вызывается какая-либо из функций, производных от метода Turtle.

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

Пример простого рисунка с модулем `turtle`.

Звезда «Turtle«:

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

Файл конфигурации модуля `turtle`.

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

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

Встроенная конфигурация будет соответствовать следующему файлу turtle.cfg:

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 400
canvheight = 300
mode = standard
colormode = 1.0
delay = 10
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = Python Turtle Graphics
using_IDLE = False

Краткое объяснение записей конфигурации:

Первые четыре строки соответствуют аргументам метода Screen.setup().
Строки 5 и 6 соответствуют аргументам метода Screen.screensize().
Форма пера может быть любой из встроенных фигур, например, стрелка, черепаха и т. д. Для получения дополнительной информации попробуйте help(shape).
Если не хотите использовать цвет заливки (т.е. сделать черепаху прозрачной), то необходимо написать fillcolor = '' (при этом, в cfg-файле непустые строки не должны иметь кавычек).
Если необходимо отразить состояние модуля turtle, то необходимо использовать resizemode = auto.
Записи exampleturtle и examplescreen определяют имена этих объектов в том виде, в котором они встречаются в строках документации. Преобразование строк документации методов в строки документации функций удалит эти имена из строк документации.
using_IDLE: Установите значение True, если регулярно работаете с IDLE и его переключателем -n. Это предотвратит переход turtle.exitonclick() в основной цикл.

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

Пакет с примерами `turtledemo`.

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

Кроме того, можно запускать демонстрационные скрипты индивидуально. Например,

python -m turtledemo.bytedesign

Каталог пакета turtledemo содержит:

Программу-просмотрщик __main__.py, которую можно использовать для просмотра исходного кода скриптов и их одновременного запуска.
Несколько скриптов, демонстрирующих различные функции модуля turtle. Доступ к примерам можно получить через меню «Examples«. Их также можно запускать автономно.
Файл turtle.cfg, который служит примером того, как писать и использовать такие файлы.

ПРИМЕЧАНИЕ: Если запуск в терминале команды python -m turtledemo выдает /usr/bin/python: No module named turtledemo, то необходимо установить файлы примеров установленной версии Python. Например для Linux:

sudo apt install python3-examples idle3

И все заработает…

Установка поддержки `Tk` для Python3 (Tkinter) в Linux/X11.

Запустите оболочку Python (например, /usr/bin/python3) и проверьте импорт модуля turtle (например from turtle import *). Если при попытке импортировать turtle выводится сообщение об ошибке «ModuleNotFoundError: No module named ‘tkinter’«, то в большинстве случаев сообщение говорит о том, что нужно установить поддержку Tcl/Tk.

В основном дистрибутивы Linux выделяют поддержку Tkinter в отдельный пакет. Это избавляет от установки библиотек Tcl/Tk для людей, которые используют Python, но не используют Tkinter. Проще говоря, необходимо установить пакет с именем python3-tk, который и обеспечит установку и поддержку в системе соответствующих версий библиотек Tcl/Tk.

$ sudo apt install python3-tk

В данном случае этот пакет предоставляет библиотеки Tcl/Tk для использования с Python3.

Источник

Об языке

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

О модуле

Библиотека turtle — это расширения языка Питон, позволяющее рисовать на экране несложные рисунки. По экрану компьютера ползает маленькая черепашка (`turtle’). Вы можете управлять движением черепашки, отдавая ей различные команды.

Что из себя представляет «холст»

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

Команды перемещения черепашки

forward(n) или fd(n) — Проползти вперед n шагов (пикселей).
backward(n) или bk(n) — Проползти назад n шагов (пикселей).
left(angle) или lt(angle) — Повернуться налево на angle градусов.
right(angle) или rt(angle) — Повернуться направо на angle градусов.
circle(r) — Нарисовать окружность радиуса |r|, центр которой находится слева от черепашки, если r>0 и справа, если r<0.
circle(r,angle) — Нарисовать дугу радиуса |r| и градусной мерой angle.
Дуга рисуется против часовой стрелки, если r>0 и по часовой стрелке, если r<0.
goto(x,y) — Переместить черепашку в точку с координатами (x,y).

Команды рисования черепашки

down() — Опустить перо. После этой команды черепашка начнет оставлять след при любом своем передвижении.
up() — Поднять перо.
width(n) — Установить ширину следа черепашки в n пикселей.
сolor(s) — Установить цвет следа черепашки в s. s должно быть текстовой строкой,
заключенной в кавычки, с названием цвета (по-английски), например, «red», «yellow», «green» и т.д.
begin_fill() — Используется для начала рисования закрашенной области.
end_fill() — Используется для окончания рисования закрашенной области.

Прочие команды

reset() — Возврат черепашки в исходное состояние: очищается экран, сбрасываются все параметры, черепашка устанавливается в начало координат, глядя вправо.
сlear() — Очистка экрана.
write(s) — Вывести текстовую строку s в точке нахождения черепашки.
radians() — Установить меру измерения углов (во всех командах черепашки) в радианы.
degrees() — Установить меру измерения углов (во всех командах черепашки) в градусы. Этот режим включен по умолчанию.
shape(«turtle») — Установить черепашке форму «черепашка»
speed(n) — Установить скорость черепашки

Зачем мы используем модуль?

Это интересно. Многие дети (да и взрослые) любят рисовать и создавать, проявляя свое творческое начало
Вычисление текущей позиции черепашки, угла поворота и тп развивают у детей математические способности и способности анализировать ситуацию
Дети приходят разного «уровня» программирования, с помощью черепашки можно в интересной форме понять основы языка, включая табуляцию, переменные, условный оператор, циклы, функции
Когда мы начинаем решать задачи, ребята уже знают как писать простые программы

Как проходят занятия

Знакомим детей со средой
Знакомим детей с модулем и простыми командами черепашки
Рисуем простейшие фигуры — квадрат, треугольник, звезда…
Фигуры посложнее — снеговик, смайлик…
Показываем, что многие вещи будет проще сделать с помощью цикла
Вводим понятие переменной, а затем и функции, тем самым рисунок перестает быть статичным

Далее вас ограничивает лишь ваша фантазия.

Программа для рисования квадрата

import turtle	# Подключаем модуль
turtle.forward(20)	# Проползти 20 пикселей вперед
turtle.left(90)	# Поворот влево на 90 градусов
turtle.forward(20)
turtle.left(90)
turtle.forward(20)	# Рисуем вторую сторону квадрата
turtle.left(90)	# Рисуем третью сторону квадрата
turtle.forward(20)	# Рисуем четвертую сторону

И еще раз квадрат:

import turtle #	Подключаем модуль
turtle for i in range(4):	# Повторить 4 раза
turtle.forward(20)	# Проползти 20 пикселей вперед
turtle.left(90)	# Поворот влево на 90 градусов

А можно так:

import turtle #	Подключаем модуль
turtle i=0	#создаем счетчик
while i<4:
turtle.forward(20)	# Проползти 20 пикселей вперед
turtle.left(90)	# Поворот влево на 90 градусов
i+=1	# увеличиваем счетчик

С помощью функции:

def square(n):	# Создаем функцию с параметром
n for i in range(4):	# Повтори 4 раза
turtle.forward(n)	# Проползти 20 пикселей вперед
turtle.left(90)	# Поворот влево на 90 градусов
import turtle	# Подключаем модуль
turtle a=int(input())	#Вводим длину стороны square(a) #Вызываем функцию

Интересные факты

• Сохраняя, нельзя называть программу по имени модуля, т.е. «turtle», иначе Python пытаться импортировать вашу программу.

• Можно создать несколько черепашек. Для этого достаточно присвоить им имена. Например:

t1=turtle.Turtle()

t2=turtle.Turtle()

При этом можно управлять ими по отдельности, обращаясь по имени, например:

t1.shape(«arrow»)

t2.shape(«turtle»)

А если посложнее?

Для «продвинутых» ребят есть задания и посложнее. Например с помощью черепашки можно сделать ковёр и треугольник Серпинского.

Спасибо за внимание!

Удачи в экспериментах с черепашкой!

Источник

Начало работы. Движения

Геометрические фигуры

Самостоятельно:

Решения

Изменяем параметры во время движения

Больше программирования!

Координаты на плоскости

Круг и точка

Самостоятельно:

Решения

Делаем фигуры равновеликими

Другие полезные функции:

Пример двух рисунков – экземпляров класса Turtle() – на одном полотне

Итог: функции и классы на примере turtle

Графический интерфейс средствами библиотеки turtle.

Самостоятельно:

Уточнения

Управляем рисунком с клавиатуры

Самостоятельно:

Соединяем все вместе

Самостоятельно:

Подсказки

Игра с подсчетом ходов

Ссылки

Окно программы

Команды перемещения черепашки

Команды рисования

Прочие команды

Пример. Два пересекающихся отрезка под прямым углом не параллельно осям координат

Упражнения

Добавить комментарий

Awesome Python Turtle Codes

1. Python Turtle Code For Star

2. Python Turtle Code For Circle

3. Python Turtle Code For Doraemon

4. Python Turtle Code For Flower

5. Python Turtle Code For Pikachu

6. Python Turtle Code For Iron Man

7. Python Turtle Code For Heart

8. Python Turtle Code For Shinchan

9. Python Turtle Code For Spiral Circle

10. Python Turtle Code For Drawing Rainbow

11. Python Turtle Code For Rainbow Spiral

Summary

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

Содержание:

Общие сведения и подходы работы с модулем.

Пример простого рисунка с модулем turtle.

Файл конфигурации модуля turtle.

Пакет с примерами turtledemo.

Установка поддержки Tk для Python3 (Tkinter) в Linux/X11.

Пример простого рисунка с модулем `turtle`.

Файл конфигурации модуля `turtle`.

Пакет с примерами `turtledemo`.

Установка поддержки `Tk` для Python3 (Tkinter) в Linux/X11.