Черепашка егэ информатика питон - Помощь в подготовке к экзаменам и поступлению

Привет! Сегодня разберём новый тип 6 задания из ЕГЭ по информатике 2023! Добавим недостающий пазл в видеокурс по подготовке к ЕГЭ по информатике.

Так же Вы можете посмотреть разбор 6 задания из ДЕМОВЕРСИИ 2023.

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

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

Рассмотрим первую тренировочную задачу из 6 задания ЕГЭ по информатике 2023.

Задача (Элегантный способ)

Повтори k [Команда1 Команда2 … КомандаS]

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

Повтори 15 [Вперёд 15 Направо 120]

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

Решение:

В начале нужно понять, какая фигура получится в результате действий Исполнителя Черепахи.

Черепаха идёт вверх на 15 единиц. Потом поворачивает направо на 120 градусов. Потом идёт на 15 единиц по заданному курсу и снова поворачивает на 120 градусов, идёт на 15 единиц ещё и попадает в исходную точку. В итоге получается равносторонний треугольник! Дальнейшие повторения не имеют смысла, т.к. нового больше ничего не нарисуется.

Проведём перпендикуляры от каждой точки с целыми координатами на оси Y внутри треугольника.

Для каждой точки на оси Y мы можем найти этот перпендикуляр. Это и есть искомое количество точек на каждой такой линии, если округлить это значение в меньшую сторону.

Посмотрим, как найти такой перпендикуляр, если точка на оси Y находится до середины стороны. Пусть есть точка (0, y_n), а d_n — это перпендикуляр для этой точки. Тогда

tg(60^o) = d_n / y_n
d_n = tg(60^o) * y_n

Для второй половины длины перпендикуляров будут такие же.

Напишем программу на Питоне, которая подсчитает все точки.

import math

s=0

for y in range(0, 8):
    s = s + int(math.tan(math.pi / 3) * y )

s = 2*s

print(s)

Нам необходимо взять первые 7 точек, дальше ситуация симметричная. Пишем в цикле for 8, потому что последнее число не проходится в Питоне.

Вычисляем по формуле длину каждого перпендикуляра. Тангенс вычисляется с помощью функции math.tan. Для неё нужна математическая библиотека math. Функция должна получить градусы в радианах, поэтому ей передаём π/3 = 60^o.

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

Ответ: 90

Задача(Считаем точки вручную)

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 16 [Налево 36 Вперёд 4 Налево 36]

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

Решение:

В это задачке достаточно не просто составить уравнения прямых полученной фигуры. В таких случаях можно попробовать вручную посчитать точки с помощью известной программы Кумир от НИИСИ РАН. Скачать её можно с официального сайта НИИСИ РАН.

Вероятно, это программа окажется на компьютере на экзамене.

Запустим программу Кумир-Стандарт. В начале нужно подключить модуль Черепаха.

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

использовать Черепаха
алг
нач
  опустить хвост
  нц 16 раз
    влево(36)
    вперед(4)
    влево(36)
  кц
кон

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

Опускаем хвост у Черепахи. Цикл пишем с помощью команды нц — начало цикла. Команда кц — это конец цикла. Команда влево — это аналог команды Налево (видим, что эти команды пишутся по-разному). Аналогично есть команда вправо в программе Кумир. Команда вперед пишется без буквы ё.

После того, как алгоритм перенесли в программу Кумир, запускаем программу, нажав на кнопку F9 (или кнопка плей в виде треугольника).

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

Необходимо настроить масштабирование на 1.

После этого можно сделать скриншот и перенести рисунок в программу Paint, где и посчитать точки вручную.

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

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

from turtle import *

left(90)
for i in range(16):
    left(36)
    forward(4*40)
    left(36)

penup()
for x in range(-10, 10):
    for y in range(-10, 10):
        setpos(x*40, y*40)
        dot(4, 'red')

Программа выведет такую картину.

В программе подключаем модуль turtle. В начале повернём Черепаху на 90 градусов налево, с помощью команды left. Это делается из-за того, в Python Черепаха смотрит вдоль положительного направления оси абсцисс.

Далее идёт цикл, который указан в задаче. Он должен повторится 16 раз. Внутри цикла пишем программу для Черепахи. Команда left() — поворот налево (аналогично right() — поворот направо), команда forward() — это движение верёд.

4 единицы внутри команды forward() умножаются на 40. Число 40 — это коэффициент размера нашего рисунка. Попробуйте «поиграть» с этим числом, чтобы посмотреть эффект уменьшения или увеличения рисунка.

Команда penup() позволяет поднять кисть, чтобы проставить точки, которые будут символизировать точки с целыми координатами.

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

Команда setpos() ставим точки. Умножаем координаты x и y на тот же коэффициент, что использовали ранее.

Команда dot() устанавливает жирность и цвет точки.

Ответ: 31

Задача (Составляем уравнения)

Запись Повтори k [Команда 1 Команда 2 … Команда S] означает, что последовательность из S команд повторится k раз.

Черепахе был дан для исполнения следующий алгоритм:

Вперёд 100 Направо 90 Вперёд 100 Направо 30 Опусти Повтори 10 [Вперёд 25 Направо 90]

Решение:

Нарисуем общий рисунок.

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

y=k*x+b

Коэффициент k — это тангенс угла наклона α к оси X ( 0 ≤ α < π, но α ≠ π/2). Число b — это смещение прямой по оси Y относительно нуля.

Для прямой AE k₁=tan(60^o)=√3. Так же она проходит через точку (100, 100).

Найдём число b. Подставим в общее уравнение координаты точки (100, 100):

y = k*x+b = √3*100 + b = 100
b=100*(1 — √3)

Получается уравнение прямой AE:

y= √3*x + 100(1 — √3)

Найдём на сколько смещена FC по оси Y относительно AE.

cos(60^o) = 25 (сторона квадрата) / AB

AB = 25 / cos(60^o) = 25 / 0,5 = 50

Получается, что уравнение для прямой FC:

y=√3*x + 100(1 — √3) — 50

Для прямой EC k₂=-tan(30^o) = — √3/3. Эта прямая тоже проходит через точку (100, 100). Подставим эти координаты в уравнение и найдём b.

y = (-√3/3) * x + b = (-√3/3) * 100 + b = 100
b = 100(1 + √3/3)

Тогда уравнение для прямой EC получается:

y = (-√3/3) * x + 100(1 + √3/3)

Найдём на сколько смещена прямая AF относительно EC по оси Y.

cos(30^o) = 25 (длина стороны) / CD
CD = 25 / cos(30^o) = 25 / (√3/2) = 50/√3

Тогда для прямой AF:

y = (- √3/3) * x + 100(1 + √3/3) — 50/√3

Пробежимся с помощью Питона для переменной x от 0 до 150. Для переменной y от 0 до 100. Чтобы получить точку, используем вложенные циклы!

s=0

for x in range(1, 200):
    for y in range(1, 200):
        if (y < (3**0.5)*x + 100*(1-3**0.5)) and (y > (3**0.5)*x + 100*(1-3**0.5) - 50) and (y < (- 3**0.5 / 3)*x + 100*(1+ 3**0.5 / 3)) and (y > (-3**0.5/3)*x + 100*(1 + 3**0.5 /3) - 50 / 3**0.5 ):
            s=s+1

print(s)

Точки, которые лежат в квадрате должны удовлетворять следующим условиям:

Точки должны быть ниже прямых AE и EC, но выше AF и FC

Проверить выше или ниже некоторая точка M(x_m, y_m), чем прямая y=k*x+b, можно следующим образом:

Если y_m > k*x_m + b, то точка лежит выше прямой.
Если y_m < k*x_m + b, то точка лежит ниже прямой.

Данный принцип и был использован в программе.

Ответ: 625

Задача (Закрепление)

Черепахе был дан для исполнения следующий алгоритм:

Повтори 21 [Вперёд 31 Направо 60]

Копирование прямо
Решение:

Попробуем понять, какая фигура получится в итоге.

Получается правильный шестиугольник. Угол ∠СВА = 120^o. Как раз угол правильного n-угольника равен (n-2)*180^o/n. Для шестиугольника получается (6-2)*180^o/6 = 120^o.

Будем решать методом составления уравнений.

Рассмотрим прямую BC. Если провести от точки B прямую параллельную оси X, то мы увидим, что угол наклона прямой BC равен 30^o.

y = tan(30^o)*x + 31
y = (√3/3) * x + 31

Прямая DC имеет угол наклона -30^o к оси X. Она расположена выше, чем BC на МВ. Треугольник BCM равносторонний. Значит, МВ=31. Тогда уравнение для DC будет:

y = -(√3/3) * x + 62

Уравнение для AF будет:

y = -(√3/3) * x

Прямая EF имеет угол наклона 30^o относительно оси X. Смещена она вниз на AP. Треугольник AFP так же является равносторонним. Следовательно, AP = 31. Тогда для EF получается:

y=tan(30^o)*x — 31
y=(√3/3)*x — 31

Прямая AB это x=0. Найдём так же ED.

cos(30^o) = BQ / BC
BQ = BC * cos(30^o)
BQ = 31 * (√3/2)
BD = 2 * BQ = 2 * 31 * (√3/2) = 31 * √3

Значит, уравнение для ED: x = 31 * √3.

Когда уравнения готовы, можно написать программу.

k=0
for x in range(-100, 100):
    for y in range(-100, 100):
        if (y < 3**0.5 / 3 * x + 31) and (y < -(3**0.5) / 3 * x + 62) and (y > -(3**0.5) / 3 * x) and (y > 3**0.5 / 3 * x - 31) and (x > 0) and (x < 31 * 3**0.5):
            k=k+1
print(k)

Точки должны быть ниже прямых BC и CD, но выше прямых AF и EF. Так же координаты x должны быть 0 < x < 31 * √3.

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

Ответ: 2476

На сегодня всё. Удачи при решение 6 задания из ЕГЭ по информатике 2023.

Зачем это делать? Авторы задания предполагают, что ученики просто воспользуются КуМир и все там получат.

В Кумире не удобно считать.

Источник

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

Версия для печати и копирования в MS Word

Запись Повтори k [Команда1 Команда2 … КомандаS] означает, что последовательность из S команд повторится k раз.

Черепахе был дан для исполнения следующий алгоритм: Повтори 7 [Вперёд 10 Направо 120].

Источник: Демонстрационная версия ЕГЭ−2023 по информатике

его движения. У исполнителя существует две команды: Вперёд n (где n  — целое число), вызывающая передвижение Черепахи на n единиц в том направлении, куда указывает её голова, и Направо m (где m  — целое число), вызывающая изменение направления движения на m градусов по часовой стрелке. Запись

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 5 [Вперёд 9 Направо 120]

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 4 [Вперёд 14 Направо 120]

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 8 [Вперёд 6 Направо 120]

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 4 [Вперёд 10 Направо 90]

Пройти тестирование по этим заданиям

Источник

Черепашья
графика,
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

Источник

Повтори k [Команда1 Команда2 … КомандаS]

Повтори 4 [Вперёд 9 Направо 90]

Повтори 3 [Вперёд 9 Направо 120]

Определите, сколько точек с целочисленными координатами будут находиться внутри области, ограниченной линией, заданной данным алгоритмом: Повтори 4 [Вперёд 9 Направо 90] и находиться вне области, ограниченной линией, заданной данным алгоритмом: Повтори 3 [Вперёд 9 Направо 120]. Точки на линии учитывать не следует.

мой код:

Python

from turtle import *
left(90)
for i in range(3):
    forward(90)
    right(90)
for i in range(4):
    forward(90)
    right(120)
pu()
for x in range(10):
    for y in range(10):
        goto(x + 10, y + 10)
        dot(5)
done()

Выходит как-то не так, помогите пожалуйста!

__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь

Источник

Черепашья графика — это один из популярных способов познакомить детей с программированием. Она была частью оригинального языка программирования Logo, разработанного Уолли Фёрзегом и Сеймуром Пейпертом в 1966 году.
Сейчас Черепашка является одним из модулей языка программирования Python и входит в его стандартную поставку. Чтобы начать пользоваться Черепашкой достаточно установить на компьютер интерпретатор языка Python.
Для начала работы с Черепашкой, необходимо импортировать модуль Turtle командой import.

#Импортируем модуль turtle
import turtle

Теперь мы можем использовать команды из этого модуля. Чтобы их использовать надо записать имя объекта, которым мы управляем, поставить точку, а затем указать команду, которую этот объект должен выполнить. У большинства команд есть параметры, указывающие как она должна выполниться, они записываются в скобках. Для примера команда turtle.forward(50) скажет нашей черепашке двигаться вперед на 50 пикселей.
Черепашка всегда появляется в середине холста. Эта точка с координатами x = 0 и y = 0.

Система координат Черепашки

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

#Добавить, чтобы окно не закрывалось
turtle.mainloop()

Источник

Исполнитель ‹‹Черепаха››

1. Использование исполнителя

Исполнитель ‹‹Черепаха›› входит в Вашу поставку Кумир, но его функции не являются частью языка программирования. Для его использования необходимо в программе явно указать использование данного исполнителя:

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

2. Команды действий

поднять хвост
Синтаксис:

алг поднять хвост

Черепаха поднимает хвост. Теперь при перемещении Черепаха не будет чертить линию.
опустить хвост
Синтаксис:

алг опустить хвост

Черепаха опускает хвост. Теперь при перемещении Черепаха будет чертить линию.
вперед
Синтаксис:

алг вперед(цел а)

Черепаха перемещается вперёд на заданное количество точек (пикселей).
а – количество пикселей, на которое переместится Черепаха.
назад
Синтаксис:

алг назад(цел а)

Черепаха перемещается назад на заданное количество точек (пикселей).
а – количество пикселей, на которое переместится Черепаха.
влево
Синтаксис:

алг влево(цел угол)

Черепаха поворачивается влево на заданный угол.
угол – значение угла (в градусах), на который повернётся Черепаха.
вправо
Синтаксис:

алг вправо(цел угол)

Черепаха поворачивается вправо на заданный угол.
угол – значение угла (в градусах), на который повернётся Черепаха.

Задание 6 (ИНФ-11 ЕГЭ 2023_ДЕМО)

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

Решение:

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

Вспомним график линейной функции

Ответ: 38

Источник

Сильное желание чему то научиться — это уже 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. Нарисуйте сами какую-нибудь цветную картинку (дом, дерево, рожицу, компьютер, …).

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

Источник