F97LF


VPython. Введение
=================

Английский оригинал статьи в

  http://vpython.org/contents/docs/VPython_Intro.pdf

1. Обзор
   -----

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

  o Python, язык программирования, разработанный в 1990 году Гвидо ван Россумом (Guido van Rossum), голландским ученым специалистом в области информатики. Python является современным, объектно-ориентированным языком, который легко изучать.

  o Visual,  модуль 3D-графики для Python созданный в 2000 году Дэвидом Шерером (David Scherer), будучи студентом в университете Карнеги-Меллона. Visual позволяет создавать и анимировать 3D объекты, а также для перемещаться по 3D сцене с помощью мыши, меняя точку наблюдения.

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

Это руководство предполагает, что Python и Visual установлены на компьютере, который вы используете.


2. Ваша первая программа
   ---------------------

  > Запустить IDLE. В Windows, может быть значок на рабочем столе, или найдите "IDLE (Python GUI)" в папке Python в меню программ. На Macintosh, двойным щелчком в Applications/VPython. Должно появиться окно с надписью "Без названия". Если вместо него появится непустое окно "оболочка Python", в меню Файл выберите "Новое Окно".

  > В пустом окне, в качестве первой строки вашей программы, введите следующее предложение:

    from visual import *

Это предложение указывает Python использовать модуль Visual.

  > В качестве второй строки вашей программы, введите следующее предложение:

    sphere()


3. Запуск программы
   -------------------

  > Теперь запустите программу, нажав F5 (или выбрав "Запустить программу" в меню "Run"). Когда вы запустите программу, появится окно с названием "VPython", в котором вы должны увидеть белую сферу, и окно с названием "Python Shell". Переместите окно Shell в нижнюю часть экрана, где оно не мешает, но вы все еще можете увидеть его (вы можете сделать его меньше, если вы хотите).

  > В окне VPython, удерживая левую + правую кнопки двухкнопочной мыши (или клавишей опции на Macintosh) и переместите мышь. Вы должны увидеть, что вы способны приблизиться к сцене или удалиться от сцены.

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

Имейте в виду, что вы перемещаете камеру вокруг объекта. При увеличении масштаба и поворот вы перемещаете камеру, а не объект.


4. Остановка программы
   --------------------

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


5. Сохраните программу
   -------------------

Если вы еще не сохранили программу, сохраните ее сейчас, потянув вниз меню "Файл" и выбрав "Сохранить как". Дайте программе имя, с расширением "py", такое, как "MyProgram.py". Вы должны ввести ".py" расширение; IDLE не будет поставлять его, и если он опущен IDLE не раскрасит вашу программу, чтобы определить различные компоненты, а это  полезно. Каждый раз, когда вы запустите программу, IDLE будет сохранять ваш код перед запуском. Вы можете отменить изменения в программе, нажав CTRL-z.

6. Мяч в коробке
   -------------

Цель следующей деятельности -- дать вам опыт использования скорости, чтобы иметь возможность обновить положение объекта при создании 3D-анимации. Вы будете писать программу, в которой шар будет прыгать в коробке, в 3D.

Для позиционирования объектов в окне дисплея мы используем их 3D-координаты. Начало системы координат находится в центре окна дисплея. Положительное направлениие оси х -- вправо, у -- вверх, и z -- выходит из экрана, к вам.

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

  from visual import *
  ball = sphere(pos=(-5,0,0), radius=0.5, color=color.cyan)
  wallR = box(pos=(6,0,0), size=(0.2,12,12), color=color.green)

Как и с объектом sphere, атрибут VPython объекта box позиционирует центр коробки. Атрибут size определяет ширину (по оси x), высота (по оси y) и глубину (по оси z). Поскольку ширина была указана, чтобы быть всего 0.2, объект box выглядит как тонкая стенка. Есть 9 цветов легко доступных на color.xxx: red, green, blue, yellow, magenta, cyan, orange, black, и white. Можно создавать свои собственные цвета.


7. Обновление положение мяча
   -------------------------

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

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

  > Добавьте это предложение в вашу программу:

    ball.velocity = vector(25,0,0)

Мы должны указать интервал времени между "снимками". Мы назовем этот очень короткий промежуток времени "deltat" чтобы представить delta t. В контексте программы, мы говорим о виртуальном времени (то есть, о времени в нашем виртуальном мире); виртуальный интервал времени в 1 секунду может занять гораздо меньше времени, чем одну секунду на быстром компьютере. Чтобы отслеживать, как много прошло времени в сумме, давайте также сбросим "секундомер" времени t на нулевую отметку.

  > Добавить эти предложения в вашу программу:

    deltat = 0.005
    t = 0

Если вы запустите программу, ничего не случится, потому что мы еще не дали инструкции о том, как использовать скорость, чтобы обновить положение шара. Мы должны использовать "position update", как отношение между положением, скоростью, и промежутком времени, так, что окончательная позиция (вектор) является начальной позицией плюс средняя скорость помноженная на временной интервал:

  rf = ri + v * deltat

Это соотношение справедливо, если скорость почти постоянна (как величина так и направление) в течение интервала времени deltat. Если скорость изменяется (по величине и / или направлению), необходимо использовать настолько короткий промежуток времени, что скорость в начале временного интервала почти такая же, как средняя скорость в течение всего интервала времени.

Мы должны перевести стандартные обозначения на VPython язык:

    ball.pos = ball.pos + ball.velocity * deltat

Так же, как скорость, так и положение мяча, ball.pos, являются векторами. Как и в большинстве языков программирования, знак равенства означает что-то другое, чем то, что он делает в обычной алгебре. В VPython, знак равенства используется для присваивания, а не равенства. То есть, строка назначает вектору ball.pos новое значение, которое равно текущему значению ball.pos плюс смещение (или изменение положения) ball.velocity * deltat.

8. 3D анимация: Постоянное обновление позиции мяча
   -----------------------------------------------

Ваша программа должна выглядеть так:

    from visual import *
    ball = sphere(pos=(-5,0,0), radius=0.5, color=color.cyan)
    wallR = box(pos=(6,0,0), size=(0.2,12,12), color=color.green)
    ball.velocity = vector(25,0,0)
    deltat = 0.005
    t = 0
    ball.pos = ball.pos + ball.velocity*deltat

  > Запустите программу.

Не так много происходит! Проблема в том, что программа проходит только один шаг по времени; мы должны пройти много шагов. Чтобы достичь этого, мы пишем цикл while. Цикл while настраивает компьютер на выполнение ряда команд снова и снова, пока мы не вынудим его остановиться.

  > Вставьте следующую строку как раз перед вашим предложением обновления позиции (то есть, как раз перед последним предложением):

    while t < 3:

Не забывайте двоеточие! Обратите внимание, что при нажатии клавиши "RETURN" (в IDLE), курсор появится в новой строке с отступом по отношению к предложению while. Cтроки с отступом, следующие за while, расположены внутри цикла; то есть, они будут повторяться снова и снова. В этом случае они будут повторяться до тех пор, пока "секундомер" времени t меньше, чем 3 секунды.

  > Выровняйте положение строки обновления позиции внутри цикла while:

    ball.pos = ball.pos + ball.velocity * deltat

Обратите внимание, что если вы установите курсор на конец while предложения, IDLE автоматически сделает отступ следующих строк при нажатии ENTER. Другой способ -- это нажать TAB для отступа строки. Все предложения с отступом после предложения while будут выполняться каждый раз, пока цикл выполняется.

  > Также обновите секундомер времени, добавив deltat к t для каждого прохода через цикл:

    t = t + deltat

Ваша программа должна выглядеть так:

    from visual import *
    ball = sphere(pos=(-5,0,0), radius=0.5, color=color.cyan)
    wallR = box(pos=(6,0,0), size=(0.2,12,12), color=color.green)
    ball.velocity = vector(25,0,0)
    deltat = 0.005
    t = 0
    while t < 3:
        ball.pos = ball.pos + ball.velocity*deltat
        t = t + deltat

  > Запустите программу.

В зависимости от скорости вашего компьютера, мяч может перемещаться так быстро, что вы увидите только мелькание! Кроме того, VPython по умолчанию пытается сохранить все объекты видимыми, так по мере удаления мяча от начала координат, VPython будет отодвигать "камеру" от сцены, и стенка отступит вдаль. Это называется "autoscaling".

  > Чтобы замедлить анимацию, вставьте следующее предложение внутрь цикла (сразу после предложения while, с отступом, как обычно):

    rate(100)

Это указывает, что цикл while не будет выполнен более чем 100 раз в секунду, даже если ваш компьютер способен сделать это намного быстрее.
(Как это работает: при каждом прохождении цикла VPython проверяет, прошла ли 1/100 секунды реального времени с момента предыдущего цикла. Если нет, VPython ждет, пока столько времени не пройдет. Это гарантирует, что цикл будет пройден не более 100 раз за одну секунду.)

  > Запустите программу.

Вы должны видеть мяч смещается вправо медленнее. Тем не менее, он продолжает идти прямо через стену, в пустое пространство, потому что это то, что было сказано сделать. VPython не знает ни физики! Вы должны сказать ему, что делать.

9. Создание отскока мяча: Логические тесты
   ---------------------------------------

Для того, чтобы мяч отскакивал от стены, мы должны обнаружить столкновение между мячом и стенкой. Простой подход состоит в том, чтобы сравнить х-координату мяча с x-координатой стенки, и обратить вспять х компонент скорости шара, если мяч ушел слишком далеко вправо. В VPython вы можете получить доступ к х, у или z компонентам любого вектора со ссылкой на х, у или z атрибуты этого вектора. В приведенных ниже предложениях, ball.pos является вектором, но ball.pos.x является х компонентой этого вектора. Точно так же, ball.velocity является вектором, а ball.velocity.x является х компонентой этого вектора.

  > Вставьте эти предложения в ваш цикл while, как раз перед вашим предложением обновляющим позицию мяча (для отступа строк нажмите Enter в конце предыдущего предложения, или нажимайте TAB перед новыми предложениями, или выберите "new statements" и используйте опцию "Indent region" в меню "Format" для отступа строк):

    if ball.pos.x > wallR.pos.x:
        ball.velocity.x = -ball.velocity.x

предложения с отступом после предложения if, будут выполнены (и в х-компоненте скорости изменен знак), только если логическая проверка в предыдущей строке дает истину при сравнении. Если результат логического теста ложь (то есть, если координата х мяча не больше, чем координата х стенки), строки с отступом будут пропущены. Мы хотим, чтобы этот логический тест выполнялся каждый раз, когда мяч перемещается, так что мы должны сделать отступ в обоих этих строках, так как они находятся внутри цикла while.

Ваша программа должна выглядеть так:

    from visual import *
    ball = sphere(pos=(-5,0,0), radius=0.5, color=color.cyan)
    wallR = box(pos=(6,0,0), size=(0.2,12,12), color=color.green)
    ball.velocity = vector(25,0,0)
    deltat = 0.005
    t = 0
    while t < 3:
        rate(100)
        if ball.pos.x > wallR.pos.x:
            ball.velocity.x = -ball.velocity.x
        ball.pos = ball.pos + ball.velocity*deltat
        t = t + deltat

  > Запустите программу.

Вы должны заметить, что мяч движется вправо, отскакивает от стенки, а затем перемещается влево, продолжая уходить в пространство. Обратите внимание, что наш тест не очень сложный; поскольку ball.pos.x находится в центре шара и wallR.pos.x находится в центре стены, если вы посмотрите внимательно, вы можете увидеть, что мяч, кажется, немного проникает в стену. Можно, если вы хотите, сделать это испытание более точным, используя радиус шара и толщину стенки.

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

  > Далее, перед циклом while, измените начальную скорость так, чтобы иметь ненулевую компоненту у:

    ball.velocity = vector(25,5,0)

Когда вы запустите программу, мяч отскакивает даже там, где нет стены! Опять же, вопрос в том, что VPython не знает физики. Если мы требуем изменить направление движения мяча при достижении линии стенки, VPython идет и делает это, имеет это физический смысл или нет. Мы исправим это позже.

10. Визуализация скорости
    ---------------------

Мы часто хотим визуализировать векторные величины, такие как скорость шара. Мы можем использовать объект "arrow", чтобы визуализировать скорость мяча.

  > Перед циклом while, но после предложения программы, в которой устанавливается скорость мяча, создать стрелку, которую вы будете использовать для визуализации вектора скорости мяча. Хвост стрелки на месте заданном в pos, и мы выбираем, что это будет позицией мяча. Кончик стрелки находится на луче от pos в направлении вектора скорости шарика на расстоянии ball.velocity от pos.

  varr = arrow(pos=ball.pos, axis=ball.velocity, color=color.yellow)

Важно создать стрелку перед циклом while. Если мы это предложение поместим в обозначенное отступом область кода после while, мы будем создавать новую стрелку в каждой итерации. Мы скоро станем иметь большое количество стрелок. Это сделает выполнение программы очень медленным.

  > Запустите программу.

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

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

  > Изменить предложение "arrow" использовав масштабный коэффициент как в примере ниже, а затем запустите программу:

    vscale = 0.1
    varr = arrow( pos=ball.pos, axis=vscale * ball.velocity, color=color.yellow)

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

  > Внутри цикла while, обновите атрибуты положения и оси стрелки, названные varr, так, что хвост стрелки всегда на мяче, а ось стрелки представляет текущий вектор скорости. Не забывайте использовать масштабный коэффициент vscale для масштабирования оси стрелки. Запустите программу.

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

11. Автомасштабирование
    -------------------

По умолчанию, VPython "автомасштабирует" сцену, непрерывно перемещая камеру вперед или назад, так что все объекты на сцене оказываются в поле зрения. При желании, вы можете отключить автоматическое масштабирование после создания первоначальной сцены.

  > Просто перед циклом while, после прорисовки начальной сцены, выключите дальнейшее автомасштабирование:

    scene.autoscale = False

12. Оставить след
    -------------

Часто мы заинтересованы в траектории движущегося объекта, и хотели бы, чтобы он оставил след. Мы можем сделать след из объекта "curve". Curve представляет собой упорядоченный список точек, которые соединены линией (на самом деле тонкой трубкой). Мы создадим объект "curve" до цикла while, и будем добавлять точку к нему каждый раз, когда мы двигаем мяч.

  > После создания мяча, но до цикла while, вставьте следующее заявление для создания объекта curve

    ball.trail = curve(color=ball.color)

Этим создается объект curve, связанный с шаром, цвет которого такой же, как цвет шара, но пока без каких-либо точек на кривой.

  > Внутри цикла while, после обновления позиции мяча, добавить следующее предложение:

    ball.trail.append(pos=ball.pos)

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

13. Как работает ваша программа
    ---------------------------

В вашем цикле while вы постоянно меняете положение мяча (ball.pos); Вы также можете изменить его цвет или радиус. В то время как ваш код работает, VPython одновременно выполняет другую программу ("параллельный поток"), который периодически использует информацию о текущих атрибутах ваших объектов, таких как атрибуты ball.pos и varr.axis, чтобы нарисовать новую сцену. Эта дополнительная программа (rendering thread) делает необходимые вычисления, чтобы выяснить, как нарисовать текущую версию сцены на экране компьютера, и инструктирует компьютер, чтобы создать эту картину. Это происходит много раз в секунду, поэтому анимация выглядит непрерывной.

14. Мяч внутри коробки: отскок от всех четырех стенок
    -------------------------------------------------

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

  o Добавьте верхние и нижние стенки, и заставьте мяч отскакивать от этих стенок.
  o заставьте стенки касаться друг друга, образуя часть большой коробки.
  o Добавьте заднюю стенку, и "невидимую" переднюю стенку, и заставьте мяч отскакивать и от этих стенок. Не рисуйте переднюю стенку, но включите в программу if предложение, чтобы предотвратить проход мяча через фронт.
  o Дайте мячу компонент скорости в направлении z, так что он будет отскакивать от передней и задней стенок. Сделайте начальную скорость шара такой:

    ball.velocity = vector(25, 5, 15)

Законченая программа должна обладать следующие свойствами:

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

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

15. Игра вокруг
    -----------

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

  o Вы можете сделать программу работать намного дольше, перейдя к while t < 3e4: или вы можете запустить еe "навсегда", перейдя к while True:, так как условие всегда истинно.
  o вы хотели бы добавить еще несколько мячей, с различными начальными положениями и начальных скоростей. Внутри цикла вы будете нуждаться обновления позиции для каждого шара.
  o вы могли бы сделать игру "Pong", перемещая стены вокруг под мыши или клавиатуры управления. См. разделы взаимодействий мыши и взаимодействий клавиатуры в онлайн справочнике по visual, доступной из меню Справка в IDLE.
  o вы можете создавать свои собственные цвета, используя дробные значения для показа количества красного, зеленого и синего. Например, если вы укажете цвет = (1, 0.7, 0.7), вы получите розовый цвет (100% красного, 70% зеленого, 70% синего). Пример программы colorsliders.py позволяет экспериментировать с цветами.
  o Вы можете изменить цвет шара или стенки в момент столкновения.
  o После предложения

    from visual import *

добавьте предложение

    scene.stereo = 'redcyan'

(или используйте 'redblue') и ваша сцена будет в стерео для использования с красно-голубыми (или красно-синими очками) (красная линза на левый глаз).

Вы также можете указать 'passive' или 'crosseyed' для walleyed или crosseyed стерео.

16. Примеры программ
    ----------------

Если вы выходите из VPython и перезапускаете его, вы должны увидеть, что выбор "Open" в меню File предоставляет доступ к большому количеству примеров программ, написанных на VPython, которые могут предложить вам полезные идеи.


Приложение А. Виртуальная машина Debian Jessie
----------------------------------------------

Создать на основе mini ISO + EAOI8-UtopicVBox.txt

TightVNC
--------

Remote Graphics

  $ sudo apt-get install tightvncserver*
  $ tightvncserver**
  New 'X' desktop is raspberrypi:2
  Starting applications specified in /home/pi/.vnc/xstartup
  Log file is /home/pi/.vnc/raspberrypi:2.log
  $ vncserver :1 -geometry 1920x1080 -depth 24 -dpi 96
  A VNC server is already running as :1

В хосте Windows инсталлируйте tightvnc viewer с сайта

  http://www.tightvnc.com/download.php

PI автостарт

  $ pwd
  /home/pi/.config/autostart
  $ vi tightvnc.desktop
  [Desktop Entry]
  Type=Application
  Name=TightVNC
  Exec=vncserver :1 -geometry 1280x960 -depth 24 -dpi 96
  StartupNotify=false

Соединение с реальным устройством или с bridged машиной в VirtualBox.

Connect to: 10.1.15.46:1  <-- ip:дисплей
Password:   ******

Замечания

VNC viewer install: both passwords -- no change
Port forward 5901 (listen on port 5900+display).
VNCViewer exits with [x]
autostart after login only.

правило проброса порта в VirtualBox

  Name      Proto  Host IP    Port  Guest IP   Port
  TightVNC  TCP    127.0.0.1  5901  10.0.2.15  5901


Приложение Б. VPython в VirtualBox
----------------------------------

1. В VirtualBox Manager.

  Display Video -> Extended features

  [v] Enable 3D acceleration

2. В окне терминала:

  # apt-get install idle-python2.7 idle python-visual mesa-utils
  # glxinfo

Now run

  $ idle

examples are in /usr/share/doc/python-visual/examples/

Note: Works as bad as VPython 6 with XP.
      (Fills entire window on mouseover, hanoy.py).
      Works fine if only python-visual installed.

Приложение В
------------

Pi3D в VirtualBox (Ubuntu 15.04 VM)

  $ cd ~
  $ sudo apt-get update
  $ sudo apt-get upgrade
  $ sudo apt-get install mesa-utils-extra
  # installed with python-visual as a dependance
  $ sudo apt-get install python-numpy
  $ sudo apt-get install python-dev python-setuptools libjpeg-dev zlib1g-dev libpng12-dev libfreetype6-dev
  $ sudo apt-get install python-pip
  $ sudo pip install pi3d
  $ sudo pip install Pillow
  $ sudo raspi-config # set gpu_mem=128
  $ git clone git://github.com/pi3d/pi3d_demos
  $ cd ~/pi3d_demos
  $ python Earth.py

Проверка установленной версии numpy
  >>> import numpy
  >>> numpy
  <module 'numpy' from '/usr/lib/python2.7/dist-packages/numpy/__init__.pyc'>
  >>> print numpy.__version__
  1.8.2
  >>>

Приложение Г
------------

Python - продолжение строки
---------------------------

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

Тем не менее, обратные косые (backslashes) могут иногда быть целесообразными.

Пример:

  а = ('1' + '2' + '3' +
      "4" + "5")

Или:

  а = '1' + '2' + '3' + \
      "4" + "5"

Составные операторы (несколько операторов в одной строке)
---------------------------------------------------------

  if foo == 'blah': do_blah_thing()
  do_one(); do_two(); do_three()

inline if
---------

  x = a if b else c

Пример
------

  from __future__ import division, print_function;
  from visual import *;
  r = 0; g = 0; b = 0; dg = -.005;
  ball = sphere( color = (r,g,b));
  while True:
      sleep( .02);
      dg = -dg if (g + dg >= 1 or g + dg <= 0) else dg;
      ball.color = (r,g,b);
      g += dg;
      print( ball.color);

Комментарии
-----------

  # решетка-пробел и до конца строки. Например:

    х = х + 1 # Увеличить х

  ''' Строки документации.

Ссылки
------

  http://en.wikipedia.org/wiki/Python_syntax_and_semantics
  https://pi3d.github.io/html/ReadMe.html#setup-on-the-raspberry-pi
  https://git-scm.com/download/win # Git for Windows