Algorithms of Assembly · Алгоритмы сборки

От Chip Machine к Python

Один экран из фишек. Сначала печатаем, затем создаём собственные действия.

Python Laboratories · 1.1.0 · две лабораторные работы с продолжением по темпу группы

На экране уже лежат 40×40 круглых фишек. Мы смотрим строго сверху; у каждой фишки две стороны — белая и чёрная. При перевороте видим ребро, затем обратную сторону. Белая сторона обозначает 0, чёрная — 1. Новый запуск начинает с белого поля. В текстовой лабораторной программа передаёт символы, среда строит их глифы; в графической вы обращаетесь к отдельным фишкам по координатам.

Ритм каждого опыта

Посмотрите исходный результат → сформулируйте вопрос и запишите прогноз изменения → изучите объяснение → измените программу → сделайте собственный вариант → сохраните проект, откройте его заново и запустите.

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

Сначала пройдите основные задания. Дополнительные карточки расширяют уже понятное; их не нужно проходить за один день. Карточку о форматировании удобнее открыть после знакомства с переменными.

Нажмите «Пауза», затем «Шаг»: одна следующая фишка пройдёт через ребро и сменит сторону. Python ждёт завершения переворота. Подсветка показывает строку, которая сейчас выполняется. «Продолжить» возобновляет этот же запуск; «Остановить» завершает его.

Лабораторная 1

Печатаем на чипэкране

Собственная текстовая композиция, записанная несколькими способами и воспроизведённая из сохранённого проекта.

Экран: шесть знаков в строке и пять строк. Один глиф занимает 5×7 фишек. Между глифами один пустой столбец, между строками одна пустая строка фишек. Обычный print завершает вывод переводом строки.

1.1 · Основной опыт

Первый знак — первый вызов

Видимый опыт. Запустите заготовку в медленном темпе. Проследите, как фишки проходят через ребро и собирают букву A. Нажмите «Пауза», затем «Шаг». В новом запуске замените A на H.

print("A")

Вопрос и прогноз. Где появится A? Если заменить её словом FLIP, перевернётся одна фишка или появится слово?

Объяснение. print — готовая функция Python. Кавычки обозначают строку; внутри них записан символ. Его глиф 5×7 задаёт, какие фишки должны стать чёрными. Каждая нужная фишка переворачивается, после чего выполнение продолжается. В конце print переводит текстовый курсор на новую строку. Слово FLIP в кавычках тоже будет текстом.

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

Собственный опыт и сохранение. Выберите три знакомых символа и сохраните программу с одним из них. Откройте сохранённый проект и воспроизведите результат.

Проверяю себя. Объясняю, что делает вызов print, чем символ отличается от его глифа и почему FLIP в кавычках не выполняет действие.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.2 · Основной опыт

Запись выражения и его значение

Видимый опыт. Запустите две строки и сопоставьте каждый результат со своим вызовом.

print("3+2")
print(3+2)

Вопрос и прогноз. Будут ли две строки одинаковыми? Что изменится, если убрать кавычки вокруг 3+2?

Объяснение. Сначала Python вычисляет аргументы, затем print выводит их текстовое представление. Строка "3+2" сохраняет символы, а выражение 3+2 даёт число. Одинарные и двойные кавычки одинаково подходят для обычной строки.

Изменение программы. Замените выражение на 4*3. Выведите и его запись, и результат. Проверьте также отрицательное число и число с десятичной точкой.

Собственный опыт и сохранение. Составьте двухстрочную арифметическую загадку: первая строка — выражение как текст, вторая — ответ. Сохраните и откройте её заново.

Проверяю себя. До запуска различаю текст и вычисляемое выражение; могу связать строку вывода с её источником.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.3 · Основной опыт

Несколько значений и разделитель

Видимый опыт. Запустите пример и сравните три строки посимвольно.

print("A", "B", 3)
print("A", "B", 3, sep="-")
print("A", "B", 3, sep="")

Вопрос и прогноз. Сколько промежутков будет между A, B и 3? Появится ли разделитель в начале или конце строки?

Объяснение. Запятые разделяют аргументы вызова. По умолчанию print вставляет между значениями один пробел. Именованный аргумент sep задаёт другой разделитель; sep="" убирает его. После последнего значения разделитель не добавляется. На экране шесть знакомест в строке. Более длинный результат переносится; точный поток целиком виден в журнале.

Изменение программы. Используйте sep=":" и sep=" / ". Сохраните три аргумента, чтобы увидеть два разделителя.

Собственный опыт и сохранение. Напечатайте короткую цепочку из четырёх знаков с собственным разделителем, затем ту же цепочку без него. Сохраните и повторите запуск.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.4 · Основной опыт

Вызов и строка — не одно и то же

Видимый опыт. Запустите программу. Сравните её с вариантом, где удалены оба аргумента end.

print("A", end="")
print("B", end=" ")
print("C")

Вопрос и прогноз. Сколько строк займут три вызова? Где появится C?

Объяснение. После значений print обычно добавляет перевод строки. end заменяет этот завершающий текст. end="" ничего не добавляет; следующий вывод продолжается с текущего места. Вызов print() без значений выводит только свой end, обычно перевод строки.

Изменение программы. Сделайте вывод A B C на одной строке, затем добавьте пустую строку и слово END. Используйте отдельные вызовы.

Собственный опыт и сохранение. Соберите короткое сообщение из трёх вызовов и сделайте два варианта размещения. Сохраните предпочтительный вариант и откройте его снова.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.5 · Основной опыт

Перенос внутри строки

Видимый опыт. Сначала запустите заготовку, затем запишите тот же результат отдельными print.

print("A\nB\nC")

Вопрос и прогноз. Какой результат даст один вызов с двумя символами \n? Сколько строк в тексте, сколько вызовов в программе?

Объяснение. В строковом литерале \n обозначает один символ перевода строки. Он действует в самом тексте. В конце вызова print добавляет свой перевод строки, если end не изменён. Пустая строка текста тоже занимает место по вертикали.

Изменение программы. Получите A, пустую строку и B двумя способами: с \n и с print() без значений.

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

Проверяю себя. Различаю строку кода, вызов функции и видимую строку на экране.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.6 · Основной опыт

Кавычки и обратная косая черта

Видимый опыт. Запустите пример. В последней строке найдите два видимых символа: обратную косую черту и n.

print('"A"')
print("It's A")
print("\\n")

Вопрос и прогноз. Какие знаки появятся на экране, а какие нужны только для записи строки?

Объяснение. Кавычку удобно включать, выбрав снаружи кавычки другого вида. Обратная косая черта вводит специальную запись: \" — двойная кавычка, \\ — одна обратная косая черта. Поэтому "\\n" печатает два знака, а "\n" выполняет перенос.

Изменение программы. Добавьте строку с текстом "A" в кавычках и строку с одиночной обратной косой чертой.

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

Проверяю себя. Могу напечатать кавычку и обратную косую черту; объясняю различие между \n и \\n в исходной записи.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.7 · Основной опыт

Буква A из пяти строк

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

print(" ### ")
print("#   #")
print("#####")
print("#   #")
print("#   #", end="")

Вопрос и прогноз. Где окажется разрыв, если заменить третью строку на ## ##? Почему последний print не добавляет перевод строки?

Объяснение. Большая буква состоит из пяти строк по пять символов. Пробелы оставляют фон белым. Каждый символ #, в свою очередь, имеет глиф 5×7. На экране пять строк текста: end="" в последнем вызове удерживает курсор в нижней строке и не запускает прокрутку. Один print с \n может передать тот же поток.

Изменение программы. Создайте разрыв в третьей строке и восстановите его. Запишите рисунок одним print с \n или тройными кавычками; сохраните end="".

Собственный опыт и сохранение. Сделайте H или стрелку из пяти строк шириной до шести символов. Сохраните программу, откройте её и воспроизведите рисунок.

Проверяю себя. Изменяю выбранное место рисунка; получаю одинаковое изображение разными записями.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.8 · Основной опыт

Вычислить текст до печати

Видимый опыт. Запустите рамку. Найдите в коде части, отвечающие за ширину и середину.

print("+" + "-" * 4 + "+")
print("|" + " " * 4 + "|")
print("+" + "-" * 4 + "+")

Вопрос и прогноз. Почему строка рамки занимает шесть знакомест, хотя число в выражении равно четырём?

Объяснение. Оператор * с текстом и целым числом повторяет текст; + между строками соединяет их. Это подготовка аргумента до вызова print. Число 3 + 2 даёт 5, а строки "3" + "2" дают "32".

Изменение программы. Сделайте рамку шириной пять знакомест. Сначала посчитайте, сколько мест занимает её середина.

Собственный опыт и сохранение. Соберите свой узор из соединения и повторения строк. Уложитесь в шесть знаков по ширине, затем намеренно превысьте ширину и объясните перенос.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.9 · Основной опыт

Край экрана и прокрутка

Видимый опыт. Запустите программу и проследите за курсором. Затем напечатайте шесть отдельных строк с числами 1–6 и найдите, что исчезло сверху.

print("123456")
print("NEXT")
print("abcdefQ")

Вопрос и прогноз. После шести символов и перевода строки появится ли лишняя пустая строка? Где окажется Q?

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

Изменение программы. Замените первую строку на пять и на семь символов. Затем напечатайте числа 1–6 шестью отдельными print. Следите за верхней строкой и отметкой прокрутки.

Собственный опыт и сохранение. Создайте сообщение с намеренным переносом на границе. Запишите прогноз положения последнего символа, сохраните и проверьте после открытия.

Проверяю себя. Различаю перенос по ширине и явный перевод строки; объясняю исчезновение старого текста при прокрутке.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.10 · Основной опыт

Собственная текстовая композиция

Видимый опыт. Запустите небольшой образец. Объясните роль каждого sep, end и повторения строки.

print("МОЁ")
print("+", "-" * 4, "+", sep="")
print("| A  |")
print("+", "-" * 4, "+", sep="")
print("BY", "ME", sep="-", end="")

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

Объяснение. Теперь вы выбираете способ записи по задаче. Несколько вызовов удобны для отдельных строк, sep — для цепочек значений, end — для продолжения, строковые выражения — для узоров. Каждый новый запуск воспроизводит результат из белого поля.

Изменение программы. Измените заголовок и узор. Уложите композицию в пять строк по шесть знакомест. В последней строке используйте end="", чтобы не прокрутить поле.

Собственный опыт и сохранение. Сделайте свою карточку: короткий заголовок, рисунок и подпись. Используйте не менее трёх изученных способов вывода. Сохраните проект, откройте его заново, запустите и сравните с прогнозом.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:

Дополнительные опыты с печатью

Возвращайтесь к ним по мере появления вопросов; форматирование удобнее изучать после переменных.

1.11 · Дополнительно

Табуляция и возврат каретки

Видимый опыт. Запустите три строки и отметьте стартовые колонки знаков.

print("A\tB")
print("AB\tC")
print("ABCDE\rX")

Вопрос и прогноз. Будут ли пробел и табуляция занимать одинаковое место? Сотрёт ли \r всю строку?

Объяснение. В этой среде \t передвигает текстовый курсор к следующей позиции, кратной четырём знакоместам: 4, 8, 12, затем к следующей строке. \r возвращает в колонку 0 текущей строки, но не очищает её. Следующий глиф перезаписывает целое знакоместо, включая белый фон. Если табуляция пересекает шестое знакоместо, её пробелы продолжаются на следующей строке.

Изменение программы. Замените A перед первой табуляцией на ABCD. Затем замените X после \r на пробел и посмотрите, какая часть строки исчезла.

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

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.12 · Дополнительно

Символ есть, а глифа нет

Видимый опыт. Запустите пример с кириллицей и символом 🐍. Сравните изображение, предупреждение среды и полный текстовый журнал.

print("Привет")
print("A 🐍 B")

Вопрос и прогноз. Если Python хранит символ, которого нет в таблице глифов, сможет ли экран показать его исходное начертание?

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

Изменение программы. Замените 🐍 на A, затем попробуйте один самостоятельно выбранный символ. Укажите, найден ли его глиф.

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

Проверяю себя. Различаю отсутствие глифа и ошибку программы; проверяю источник символа по журналу.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.13 · Дополнительно

Значение внутри сообщения

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

n = 7
print("n=", n, sep="")
print(f"n={n}")
print("n={}".format(n))
print("n=%d" % n)

Вопрос и прогноз. Дадут ли четыре разные записи одинаковый текст? Какая часть записи задаёт внешний вид числа?

Объяснение. Переменная n хранит значение. f-строка вставляет вычисленное значение из фигурных скобок; .format() и % дают другие способы подготовки строки. Это способы создать строку перед print, а не новые режимы функции. Для новых программ удобно начать с f-строк.

Изменение программы. Измените n. Затем попробуйте print(f"n={n:03d}"): ширина 3 и ведущие нули задают представление целого числа.

Собственный опыт и сохранение. Сделайте короткую подпись к своей линии с её длиной. Используйте один способ форматирования, сохраните и повторите запуск.

Проверяю себя. Различаю значение и его текстовое представление; объясняю, что передаётся функции print.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.14 · Дополнительно

Передать сразу несколько аргументов

Видимый опыт. Запустите два вызова и сравните роль звёздочки со строковым повторением из задания 1.8.

print("ABC", sep="-")
print(*"ABC", sep="-")

Вопрос и прогноз. Почему первая строка не получает дефисы, а вторая получает?

Объяснение. Вызов print("ABC", sep="-") получает один аргумент, поэтому разделителю негде появиться. Звёздочка перед строкой в позиции аргумента распаковывает её элементы: print(*"ABC", sep="-") получает три аргумента. Это другая роль *, чем умножение строки.

Изменение программы. Замените ABC на четыре символа и задайте sep=" / ". Следите за общей длиной строки.

Собственный опыт и сохранение. Сделайте короткую последовательность знаков, которую можно вывести слитно или с разделителями. Сохраните и повторите запуск.

Проверяю себя. Могу объяснить разницу между одним строковым аргументом и несколькими отдельными аргументами.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.15 · Дополнительно

Направить вывод в другой поток

Видимый опыт. Запустите готовую заготовку. Найдите вызов, который пишет в буфер, и вызов, который выводит содержимое буфера на экран.

import io

buffer = io.StringIO()
print("SAVED", file=buffer)
print("SCREEN")
print(buffer.getvalue(), end="")

Вопрос и прогноз. Появится ли слово SAVED сразу на чипэкране? Что хранится в buffer?

Объяснение. Обычно print пишет в стандартный поток вывода, связанный здесь с текстовым экраном. Именованный аргумент file позволяет выбрать другой текстовый поток. io.StringIO хранит текст в памяти. getvalue() возвращает накопленный текст; завершающий перевод строки тоже входит в него. Это не сохранение проекта на диск.

Изменение программы. Добавьте второй print с file=buffer. Проверьте, зачем при выводе getvalue() указан end="".

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

Проверяю себя. Различаю стандартный вывод, другой текстовый поток и сохранение проекта.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.16 · Дополнительно

Что означает flush

Видимый опыт. Запустите пример, затем поменяйте flush=True на flush=False и сравните текст и экран.

print("A", end="", flush=True)
print("B", flush=False)

Вопрос и прогноз. Обязательно ли flush=True изменит изображение или создаст паузу?

Объяснение. flush=True просит текстовый поток сбросить буфер. Он не задаёт скорость переворотов, задержку или паузу. В этой среде темп задаётся рядом с экраном; конечный текст AB и рисунок одинаковы при обоих значениях flush. end управляет завершением вызова и поэтому может изменить текст.

Изменение программы. Оставьте flush=True, а видимое различие создайте только через end="-". Укажите, какой аргумент изменил текст.

Собственный опыт и сохранение. Сохраните пару коротких вариантов и запишите, какие изменения относятся к тексту, а какие — к поведению потока.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
1.17 · Дополнительно

Границы договора print

Видимый опыт. Запустите программу и свяжите каждый участок текста с вызовом.

print("A", "B", sep=None, end=None)
print(end="X")
print("Y")

Вопрос и прогноз. Что выведет print без значений, если задан end? Что означает None в sep и end?

Объяснение. У print может не быть позиционных аргументов. sep=None и end=None выбирают стандартные значения: пробел и перевод строки. sep и end принимают строки или None. Для намеренного опыта с ошибкой можно отдельно заменить sep=None на sep=0: Python сообщит TypeError. После этого восстановите работающую версию.

Изменение программы. Добавьте print(end="!") и проследите за курсором. Отдельно проверьте ошибочный sep=0, запишите смысл сообщения и исправьте программу.

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

Проверяю себя. Знаю основные параметры print: значения, sep, end, file, flush; умею отличить неверный тип аргумента от проблемы глифа.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
Лабораторная 2

Рисуем программой

Авторский рисунок и собственная функция с параметрами и возвращаемым результатом.

Координаты 0–39: x вправо, y вниз. Перевороты видны сразу. Функции из chip_screen подключены в заготовках; постепенно мы научимся определять собственные.

2.1 · Основной опыт

Фишка уже лежит на экране

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

from chip_screen import flip, read, show

print(read(12, 12))
flip(12, 12)
show("Один переворот")
print(read(12, 12))
flip(12, 12)
show("Два переворота")
print(read(12, 12))

Вопрос и прогноз. После двух flip одной точки она станет белой или чёрной? Как отличаются промежуточное состояние и итог?

Объяснение. Белая сторона — 0, чёрная — 1. flip(x, y) безусловно переворачивает существующую фишку. read(x, y) возвращает её бит. import делает функции учебной библиотеки доступными в программе. show сохраняет кадр для просмотра; это не задержка. В графической лабораторной print пишет в журнал и не рисует глифы на поле. Python ждёт завершения каждого видимого переворота; последующий read выполняется после него.

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

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

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.2 · Основной опыт

Координаты и желаемая сторона

Видимый опыт. Запустите пример, найдите крайние точки и короткий след у (10, 20). Увеличьте экран при необходимости.

from chip_screen import pixel, show

pixel(0, 0)
pixel(39, 39)
pixel(10, 20)
pixel(10, 20)
pixel(11, 20)
pixel(11, 20, 0)
show("Точки")

Вопрос и прогноз. Изменится ли точка от второго pixel с теми же аргументами? Какая координата задаёт движение вниз?

Объяснение. Верхний левый угол имеет координаты (0, 0). x растёт вправо, y вниз; допустимы целые числа от 0 до 39. pixel(x, y) делает точку чёрной; pixel(x, y, 0) делает её белой. Функция переворачивает фишку только при отличии текущей стороны от заданной. Поэтому повторный pixel сохраняет цвет, а повторный flip меняет его.

Изменение программы. Сместите точку (10, 20) сначала на 3 вправо, потом на 5 вниз. Отдельно проверьте x=40: это выход за границу, а не перенос на другую сторону. Восстановите допустимую координату.

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

Проверяю себя. Различаю flip и pixel; нахожу точку по координатам и не путаю размер поля с последним индексом.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.3 · Основной опыт

Одно имя вместо нескольких чисел

Видимый опыт. Запустите короткую линию. Измените y с 20 на 30 и сравните положение.

from chip_screen import pixel, show

y = 20
pixel(5, y)
pixel(6, y)
pixel(7, y)
pixel(8, y)
show("Четыре точки")

Вопрос и прогноз. Какие точки переместятся, если изменить только y? Сохранится ли расстояние между ними?

Объяснение. В записи y = 20 знак = связывает имя y со значением. Это присваивание, а не вопрос о равенстве. При каждом вызове pixel Python подставляет текущее значение y. Одна правка переменной меняет все вызовы, которые её используют.

Изменение программы. Перенесите линию вверх на 5 клеток. Затем замените один y числом 20 и проверьте, какая точка перестанет двигаться вместе с остальными.

Собственный опыт и сохранение. Сделайте короткую вертикаль с общей переменной x. Сохраните и воспроизведите два её положения отдельными проектами.

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.4 · Основной опыт

Следующее значение

Видимый опыт. Запустите программу и сопоставьте три точки с изменениями x. Последнее значение выведено в журнал.

from chip_screen import pixel, show

x = 5
y = 20
pixel(x, y)
x = x + 1
pixel(x, y)
x = x + 1
pixel(x, y)
print(x)
show("Три шага")

Вопрос и прогноз. Чему равно x после каждого присваивания? Что означает x = x + 1?

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

Изменение программы. Замените приращение 1 на 2. Затем изменяйте между точками и x, и y, чтобы получить три точки диагонали.

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

Проверяю себя. Прослеживаю значения по порядку и различаю изменение переменной и изменение уже нарисованного изображения.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.5 · Основной опыт

Цикл вместо двадцати вызовов

Видимый опыт. Запустите заготовку. Сравните короткую запись с двадцатью отдельными командами рисования.

from chip_screen import pixel, show

y = 20
for x in range(5, 25):
    pixel(x, y)
show("Горизонталь")

Вопрос и прогноз. Будет ли нарисована точка x=25? Сколько раз выполнится pixel?

Объяснение. for поочерёдно присваивает x значения из range. range(5, 25) включает 5 и не включает 25: это двадцать целых чисел. После двоеточия идёт тело цикла с отступом в четыре пробела. show без отступа выполнится после всего цикла.

Изменение программы. Измените границы range. Проверьте range(5, 5), range(5, 6), range(5, 25). На паузе используйте «Шаг»: каждый pixel выполняется отдельно. Затем добавьте show внутрь цикла, чтобы дать этапам названия.

Собственный опыт и сохранение. Постройте горизонталь длиной 12 точек на другой строке. Предскажите последнюю координату, сохраните и воспроизведите результат.

Проверяю себя. Правильно считаю число итераций и объясняю, что входит в тело цикла.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.6 · Основной опыт

Направление, шаг и очистка

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

from chip_screen import pixel, show

for x in range(10, 31, 2):
    pixel(x, 20)
for y in range(10, 31):
    pixel(10, y)
show("Пунктир и вертикаль")

Вопрос и прогноз. Чем различаются два цикла? Сколько точек будет в пунктире и в вертикали?

Объяснение. Третий аргумент range задаёт шаг. Неподвижная координата удерживает горизонталь или вертикаль. Если использовать одну переменную в обеих координатах, получится диагональ. clear() возвращает всё поле к белому состоянию; clear(1) делает всё поле чёрным. show позволяет сохранить вариант перед очисткой.

Изменение программы. Добавьте после первого show вызов clear(), затем нарисуйте диагональ pixel(p, p) в цикле. Добавьте clear в строку импорта. Сравните сохранённые кадры.

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

Проверяю себя. Управляю направлением и шагом; отличаю сохранённый кадр от текущего состояния поля.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.7 · Основной опыт

Выбор по прочитанному биту

Видимый опыт. Запустите программу из белого поля. Затем перед read добавьте pixel(12, 12) и повторите.

from chip_screen import pixel, flip, read, show

bit = read(12, 12)
flip(12, 12)
if bit == 0:
    pixel(13, 12)
else:
    pixel(11, 12)
print(bit)
show("Выбор по прежней стороне")

Вопрос и прогноз. Какую соседнюю точку выберет программа? Изменится ли сохранённое значение bit после flip?

Объяснение. read возвращает текущее значение, а присваивание сохраняет его под именем bit. if проверяет условие: == сравнивает значения, тогда как = выполняет присваивание. Исполняется одна из ветвей if/else, каждая со своим отступом. Последующий flip не обновляет уже сохранённое значение bit. Это знакомый порядок: прочитать сторону, выполнить действие, выбрать продолжение по прежнему биту.

Изменение программы. Перенесите чтение после flip и предскажите, почему результат изменится. Затем восстановите исходный порядок.

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

Проверяю себя. Различаю присваивание и сравнение; объясняю выбор ветви через значение, сохранённое до переворота.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.8 · Основной опыт

Готовая функция линии

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

from chip_screen import line, show

line(5, 10, 24, 10)
line(24, 10, 24, 29)
show("Угол")

Вопрос и прогноз. Исчезнет ли точка, общая для двух линий? Чем конечная координата line отличается от правой границы range?

Объяснение. line — функция нашей библиотеки, не встроенное слово Python. Она рисует точки от первого конца до второго включительно; направление может быть любым. По умолчанию точки становятся чёрными. Повторное рисование и пересечения сохраняют чёрный цвет. Аргумент value=0 позволяет рисовать белую линию.

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

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

Проверяю себя. Понимаю границы готовой функции, отличаю её от Python как языка и учитываю включённые концы линии.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.9 · Основной опыт

Определить и вызвать свою функцию

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

from chip_screen import pixel, show

def stroke():
    for x in range(5, 25):
        pixel(x, 20)

show("До вызова")
stroke()
show("После вызова")

Вопрос и прогноз. Появится ли линия сразу после def? Что изменится, если убрать вызов stroke()?

Объяснение. def создаёт функцию с именем stroke. Её тело записывается с отступом, но выполняется при вызове stroke(), а не при определении. Тело может содержать цикл, поэтому у pixel два уровня отступа. Функция объединяет уже понятные действия под новым именем.

Изменение программы. Удалите вызов stroke(), сохранив определение, и проверьте прогноз. Затем вызовите её два раза: повторное задание цвета через pixel сохраняет чёрную линию.

Собственный опыт и сохранение. Назовите собственный короткий штрих и определите его через несколько pixel или цикл. Покажите кадр до вызова и после, сохраните и откройте проект.

Проверяю себя. Могу указать определение, тело и вызов; объясняю, почему одно определение не рисует.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.10 · Основной опыт

Параметры делают функцию пригодной для повторения

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

from chip_screen import pixel, show

def horizontal(x0, y, length):
    for x in range(x0, x0 + length):
        pixel(x, y)

horizontal(5, 20, 12)
horizontal(10, 30, 20)
show("Одно правило, два вызова")

Вопрос и прогноз. Почему одно определение рисует две разные линии? Какие значения получает length при каждом вызове?

Объяснение. В определении x0, y и length — параметры. В вызове 5, 20 и 12 — аргументы, значения для одного выполнения. range(x0, x0 + length) даёт ровно length точек при неотрицательной длине. Имена параметров используются внутри функции; другой вызов получает свои значения.

Изменение программы. Измените только аргументы второго вызова. Проверьте длины 0, 1 и 20, сохраняя все координаты внутри поля. Затем вызовите horizontal(x0=8, y=35, length=9).

Собственный опыт и сохранение. Напишите vertical(x, y0, length) и вызовите её в двух местах. Сохраните проект и воспроизведите обе линии.

Проверяю себя. Различаю параметр и аргумент; меняю положение и размер через вызов, не переписывая тело.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.11 · Основной опыт

Функция может вернуть значение

Видимый опыт. Запустите пример. Найдите конец первой линии и начало второй на следующей строке; сопоставьте их с журналом.

from chip_screen import pixel, show

def horizontal(x0, y, length):
    for x in range(x0, x0 + length):
        pixel(x, y)
    return x0 + length

next_x = horizontal(5, 20, 8)
horizontal(next_x, 22, 5)
print(next_x)
show("Результат первого вызова")

Вопрос и прогноз. Что окажется в next_x? Если заменить return на print, сможет ли следующий вызов использовать результат как координату?

Объяснение. return возвращает значение вызывающему коду и завершает выполнение функции. Здесь возвращается первая координата после нарисованного отрезка. Присваивание next_x = horizontal(...) сохраняет результат вызова. print лишь выводит текст и сам возвращает None. Поэтому печать значения внутри функции не заменяет return.

Изменение программы. Измените длину первой линии и проверьте, как переместится начало второй. Отдельно замените return на print, наблюдайте ошибку следующего вызова и восстановите return.

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

Проверяю себя. Различаю рисование, вывод текста и возвращаемое значение; использую результат одного вызова как аргумент другого.

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:
2.12 · Основной опыт

Свой словарь рисунков

Видимый опыт. Запустите образец: одно правило создаёт две фигуры разного размера. Найдите параметры и возвращаемое значение.

from chip_screen import pixel, show

def cup(x0, y0, width, height):
    for y in range(y0, y0 + height):
        pixel(x0, y)
        pixel(x0 + width - 1, y)
    for x in range(x0, x0 + width):
        pixel(x, y0 + height - 1)
    return x0 + width + 3

next_x = cup(3, 5, 12, 16)
cup(next_x, 5, 16, 22)
show("Мой словарь рисунков")

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

Объяснение. Функция может вызывать другие функции — готовые и собственные. Договор описывает входные значения, видимое действие и возвращаемый результат. У нашей cup ширина и высота положительные, вся фигура помещается на поле; возвращается начало следующей фигуры с промежутком. Проверка этих условий — часть работы автора программы.

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

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

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

Мой прогноз:
Что произошло и почему:
Название проекта / результат повторного запуска:

Краткий словарь

ЗаписьЗначение
print(value, ..., sep=' ', end='\n', file=None, flush=False)Вывести значения в текстовый поток. В текстовой лабораторной стандартный поток связан с экраном, в графической — с журналом.
x = 5Присвоить имени значение. Это не сравнение.
x == 5Сравнить значения; результат — True или False.
for x in range(a, b):Поочерёдно выполнить тело с x от a до b−1 при шаге +1.
if condition: … else: …Выбрать одну из двух ветвей по условию.
def name(parameter):Определить собственную функцию. Тело выполняется при вызове.
name(argument)Вызвать функцию, передав значение параметру.
return valueЗавершить вызов и передать значение вызывающему коду.

Договор функций экрана

Используйте from chip_screen import … с именами нужных функций. Координаты — целые числа 0…39. Недопустимые координаты вызывают ошибку, перенос через край не выполняется. Значение стороны — 0 или 1.

ВызовДействие
flip(x, y)Безусловно перевернуть фишку.
pixel(x, y, value=1)Задать сторону; перевернуть только если текущее значение отличается.
read(x, y)Вернуть текущий бит.
line(x1, y1, x2, y2, value=1)Задать цвет точкам линии, включая оба конца.
clear(value=0)Задать одну сторону всем фишкам.
show(label='')Добавить именованный этап. При пошаговом выполнении остановиться на этой отметке. Перевороты видны и без show.

Управляющие символы текстового экрана: \n — новая строка, \t — следующая позиция, кратная четырём знакоместам, \r — начало текущей строки. Отсутствующий глиф получает заменитель и предупреждение; исходный символ остаётся в журнале.