Python — ваш рабочий инструмент¶

Как запустить код за минуту и начать считать, проверять и строить графики

Учебное пособие · Интегрированный курс математики, физики и информатики 7—9 класс / Подготовительный блок

[Изображение — заглушка] «Обложка модуля 0». Требуется: титульная обложка подготовительного модуля — визуальный образ вводного интегрированного курса математики, физики и информатики.

§ 1. Зачем вам Python в этом курсе¶

Представьте: перед вами формула пути при равноускоренном движении — \(s = v_0 t + \dfrac{a t^2}{2}\). Учитель просит подставить числа и нарисовать график. Вы открываете тетрадь, берёте линейку, считаете точку за точкой, размечаете оси, проводите кривую. На всю работу уходит четверть часа. А теперь меняется одно условие — например, начальная скорость, — и всё приходится переделывать с нуля.

Тот же график можно получить тремя строками кода. Точный, с подписями, с сеткой, за секунду. Хотите другую начальную скорость — поменяли одно число и запустили снова. Хотите проверить ещё пять вариантов — пять раз запустили. Линейка тут уже не нужна.

Именно так Python и живёт в этом курсе. Не как предмет, который надо сдавать, а как удобный карандаш, которым считают и рисуют. С его помощью мы будем проверять формулы (а правда ли, что \(0.1 + 0.2\) равно \(0.3\) в памяти компьютера?), быстро доводить до числа громоздкие выражения, строить графики функций, моделировать падение мяча или остывание чашки чая.

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

§ 2. Какой путь выбрать новичку¶

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

Первый путь — Google Colab. Браузер, аккаунт Google, ничего ставить не надо. Открыли страницу — и пишете код. Этот способ покрывает почти всё, что встретится в курсе: вычисления, формулы, графики. Адрес: https://colab.research.google.com.

Второй — Replit. Тоже браузер и тоже бесплатно. Он понадобится там, где нужно настоящее графическое окно: например, для рисования черепашкой (про неё разговор будет позже). Адрес: https://replit.com.

Третий — локальный Python. Скачиваете с сайта https://www.python.org и ставите на компьютер. Это нужно тем, кто хочет работать без интернета. Установка — пять минут.

Если вы только начинаете — берите Colab. Он самый простой, и его одного хватит почти на весь курс. Браузер уже открыт; больше ничего не нужно.

§ 3. Быстрый старт: Google Colab¶

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

Шаг первый. Откройте https://colab.research.google.com. Если потребуется — войдите в аккаунт Google (тот же, что для Gmail или YouTube).

Шаг второй. В меню «Файл» выберите «Создать блокнот». Названия пунктов на разных языках интерфейса звучат немного по-разному, но смысл один: новый пустой блокнот. Перед вами появится серая полоса — это ячейка, в неё пишется код.

Шаг третий. Кликните в ячейку и наберите одну строку:

print("Hello, ARISTOTEL")

Шаг четвёртый. Нажмите Shift + Enter. Под ячейкой появится:

Hello, ARISTOTEL

Готово — Python только что выполнил вашу первую программу. В первый раз сервер подключается секунд десять, дальше — мгновенно.

[Изображение — заглушка] «Первая ячейка в Colab». Требуется: снимок экрана Google Colab с первой выполненной ячейкой — код первой программы и результат её работы под ячейкой.

§ 4. Python как калькулятор¶

Привычная арифметика в Python работает почти как в школьной тетради. Создайте новую ячейку и попробуйте:

2 + 3
7 - 4
4 * 6
20 / 4
2 ** 3      # возведение в степень: 2**3 = 8
17 % 5      # остаток от деления; пригодится в задачах на делимость

Запустите ячейку — и получите результаты. Шесть ответов на шесть выражений, никаких столбиков.

Имена для чисел¶

В физике вы пишете: пусть скорость \(v\) равна 20 м/с, время \(t\) равно 5 с, найдите путь \(s = v \cdot t\). В Python это выглядит почти так же:

v = 20
t = 5
s = v * t
print(s)    # 100

Запись v = 20 здесь — не равенство в математическом смысле, а поручение: «запомни число 20 под именем v». Такое имя называется переменной. Дальше везде, где встретится v, Python подставит 20.

[Изображение — заглушка] «Переменная как ящик со значением». Требуется: схема — переменная в виде подписанного ящика: имя v на ящике, число 20 внутри него.

Похоже на алгебру — и в то же время не совсем. В алгебре буква обозначает величину, которая может быть какой угодно. В Python имя — это конкретный ящик, в котором сейчас лежит конкретное число. Положите туда другое — и старое исчезнет:

v = 20
v = 30
print(v)    # 30, а не "20 и 30"

Подробнее об этом различии — в следующей подглаве.

Серьёзная математика: библиотека `math`¶

Квадратный корень, синус, число π — всё это уже написано до вас и собрано в стандартную библиотеку math. Подключается она одной строкой:

import math

math.sqrt(2)     # ≈ 1.4142135623730951
math.sin(0)      # 0.0
math.pi          # 3.141592653589793

Запустите — и убедитесь, что всё считает. К функциям sqrt, sin, и числу pi мы будем возвращаться в курсе постоянно.

§ 5. Первый график — от формулы к картинке¶

Это тот момент, ради которого стоило открывать Colab. В новую ячейку введите такие строки:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 200)
y = x ** 2

plt.plot(x, y)
plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('y = x²')
plt.show()

Нажмите Shift + Enter — и под ячейкой появится парабола. Настоящий математический график, с подписями осей и сеткой. Десять строк кода — полминуты на набор.

Что здесь произошло? Строка x = np.linspace(-5, 5, 200) создала двести чисел, равномерно разложенных от −5 до 5; это будут координаты по оси \(x\). Следующая строка — y = x ** 2 — возвела в квадрат сразу все двести чисел; ни одного цикла, ни одной таблицы. Команда plt.plot(x, y) соединила точки линией. Остальные строки добавили сетку и подписи.

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

[Изображение — заглушка] «Парабола y = x²». Требуется: график параболы y = x², построенный средствами numpy/matplotlib, — с осями, сеткой и подписями.

§ 6. Как сохранить и организовать работу¶

Очень скоро у вас наберётся два десятка блокнотов. Если они называются Untitled1.ipynb, Untitled2.ipynb и так далее — вы потеряете нужный через неделю. Поэтому пара слов о порядке.

Все блокноты Colab сохраняются автоматически в Google Drive — нажимать Ctrl+S вам не нужно. А вот разложить их по папкам и назвать по-человечески придётся самим. В Drive имеет смысл завести папку ARISTOTEL, а внутри неё — отдельные подпапки под каждый модуль и каждую главу: «Модуль 0 (Python)», «Глава 1 (Числа и величины)» и так далее.

Имена файлов лучше подчинять одному шаблону: Глава-N_Тема_подпункт.ipynb. Например, Глава-1_Числа_0.1+0.2.ipynb — через месяц по такому имени сразу понятно, о чём блокнот. А имена вроде новый.ipynb, проба.ipynb, работа_финал_правка.ipynb — это будущая головная боль, не более того.

Комментарии в коде¶

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

# Свободное падение: начальная скорость 0, ускорение 9.81 м/с²
v0 = 0
g = 9.81
t = 3

s = v0 * t + g * t ** 2 / 2
print(s)    # путь за 3 секунды

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

[Изображение — заглушка] «Пример блокнота с комментариями». Требуется: снимок экрана блокнота с кодом, где видны строки-комментарии, поясняющие, что и зачем делает код.

[Изображение — заглушка] «Разделитель: вторая часть главы». Требуется: графический разделитель, отмечающий начало второй части главы — «программирование от руки».

§ 4 (часть 2). Функция — формула с входом и выходом¶

В первой части мы решали путь равномерного движения единственной строкой s = v * t. А если нужно посчитать путь не для одной пары (v, t), а для десятка? Перепечатывать формулу десять раз? Скучно и ошибкоопасно. Правильное решение — функция.

def path(v, t):
    return v * t

print(path(20, 5))   # 100
print(path(15, 8))   # 120
print(path(40, 0.5)) # 20.0

Запись def path(v, t): сообщает Python: «дальше идёт описание функции с именем path, у которой два входа — v и t». Строка return v * t — это собственно «что делать с входами»: умножить и вернуть результат. И всё — функция готова.

Дальше её можно вызывать сколько угодно раз: path(20, 5), path(15, 8), path(40, 0.5). Внутри каждого вызова Python подставляет ваши числа на место v и t, выполняет умножение и отдаёт результат наружу.

Перепишем для свободного падения:

def path(v0, g, t):
    return v0 * t + g * t ** 2 / 2

print(path(0, 9.81, 3))     # 44.145 м за 3 с
print(path(0, 9.81, 1))     # 4.905 м за 1 с
print(path(2, 9.81, 2))     # 23.62 м за 2 с

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

§ 5 (часть 2). Цикл `for` — многократное вычисление¶

Представьте такую задачу: посчитать путь свободного падения для каждой секунды от нуля до пяти. Можно написать шесть отдельных вычислений и шесть отдельных print. А можно — одно, но в цикле, и он сам всё повторит:

g = 9.81

for t in range(6):
    s = g * t ** 2 / 2
    print(s)

Запустите — и получите шесть строк:

Что здесь сделал Python? Строка for t in range(6): означает: «повтори тело цикла, подставляя вместо t последовательно числа 0, 1, 2, 3, 4, 5». Команда range(n) создаёт последовательность от нуля до \(n-1\); если нужно от 1 до 5 — пишут range(1, 6). А тело цикла — это всё, что идёт с отступом после двоеточия; именно эти строки повторяются на каждом шаге.

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

[Изображение — заглушка] «Иллюстрация цикла for». Требуется: схема работы цикла for — повторение тела цикла для каждого значения из последовательности.

§ 6 (часть 2). Список значений — данные для графика¶

В предыдущей подглаве мы выводили результаты на экран — и они там оставались как набор строчек. Для графика этого мало: чтобы построить кривую, нужно сохранить все значения и по оси \(x\), и по оси \(y\), и сохранить их так, чтобы потом можно было передать в plt.plot(). Для этого в Python есть списки:

g = 9.81

ts = []
ss = []

for t in range(6):
    s = g * t ** 2 / 2
    ts.append(t)
    ss.append(s)

print(ts)
print(ss)

Запустите — увидите две строки:

[0, 1, 2, 3, 4, 5]
[0.0, 4.905, 19.62, 44.145, 78.48, 122.625]

Список — это упорядоченный набор значений в квадратных скобках. Запись ts = [] создаёт пустой список; команда ts.append(t) добавляет очередное значение в его конец. Когда цикл закончится, у вас на руках будут две колонки чисел одинаковой длины — заготовка для таблицы и графика.

Здесь, к слову, видно, что стояло за «магией» из предыдущей подглавы. Когда мы строили параболу через numpy, библиотека сама готовила нам похожие два списка значений и сама передавала их в plt.plot() — мы только не видели промежуточного шага.

Никакой магии в этом нет: набор значений \(x\), набор значений \(y\), и линия, соединяющая точки. Остальное — техническая работа графической библиотеки.

§ 7 (часть 2). Первый осознанный график¶

Соберём всё, что у нас уже есть, в одну вещь: переменные, цикл, список — и получим график. Не из чужого шаблона, а из собственных данных:

import matplotlib.pyplot as plt

g = 9.81

ts = []
ss = []

for t in range(11):       # от 0 до 10 секунд
    s = g * t ** 2 / 2
    ts.append(t)
    ss.append(s)

plt.plot(ts, ss, marker='o')
plt.xlabel('Время, с')
plt.ylabel('Путь, м')
plt.title('Свободное падение')
plt.grid(True)
plt.show()

На экране появится парабола, поднимающаяся всё круче. Точки отмечены кружками, между ними — линия; оси подписаны, у графика есть заголовок. Это уже не «картинка по образцу», а портрет конкретной физической зависимости, рассчитанной вами.

Заметьте, что говорит этот график — а не только как он выглядит. По горизонтали идёт время, по вертикали — пройденный путь. Чем дольше падает тело, тем больший путь оно проходит за каждую новую секунду. Кривая загибается вверх — и именно это означает: движение ускоряется. Если бы скорость была постоянной, мы получили бы прямую. Прямая — равномерное движение; парабола — равноускоренное. Форма кривой рассказывает о физике.

И ещё одно: подписи осей здесь не украшение, а необходимость. График без подписей — как письмо без адреса: непонятно, кому и о чём. Возьмите за правило подписывать оси сразу, не откладывая на потом.

Тот же график через `numpy`¶

Сравните с подходом из предыдущей подглавы:

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(0, 10, 100)
s = 9.81 * t ** 2 / 2

plt.plot(t, s)
plt.xlabel('Время, с')
plt.ylabel('Путь, м')
plt.title('Свободное падение (numpy)')
plt.grid(True)
plt.show()

Три строки вместо цикла и двух списков. Результат — тот же график. В курсе мы будем пользоваться обоими способами. Когда важна прозрачность — берём цикл и список: видно каждый шаг, легко отлаживать. Когда важна скорость и формула уже отлажена — берём numpy: короче и быстрее.

Цикл — для понимания, numpy — для дела.

§ 8. Мини-лаборатория: равномерное движение¶

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

Шаг первый. Задаём начальные данные:

v = 60      # км/ч
T = 5       # часов наблюдения

Шаг второй. Определяем функцию для пути:

def path(v, t):
    return v * t

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

ts = []
ss = []

for t in range(T + 1):    # от 0 до 5 часов включительно
    ts.append(t)
    ss.append(path(v, t))

for t, s in zip(ts, ss):
    print(f"t = {t} ч,  s = {s} км")

На экране появятся шесть строк:

t = 0 ч,  s = 0 км
t = 1 ч,  s = 60 км
t = 2 ч,  s = 120 км
t = 3 ч,  s = 180 км
t = 4 ч,  s = 240 км
t = 5 ч,  s = 300 км

Шаг четвёртый. Строим график:

import matplotlib.pyplot as plt

plt.plot(ts, ss, marker='o')
plt.xlabel('Время, ч')
plt.ylabel('Путь, км')
plt.title('Равномерное движение: v = 60 км/ч')
plt.grid(True)
plt.show()

Получится прямая, идущая из начала координат под одним и тем же наклоном. Прямая — потому что движение равномерное; наклон — потому что скорость одна и та же на всём промежутке. Поменяете скорость — наклон изменится.

[Изображение — заглушка] «График равномерного движения». Требуется: график равномерного движения — прямая из начала координат на осях «путь — время»; наклон прямой соответствует скорости.

→ Попробуйте сами¶

Первая. Замените скорость в первой строке на 90 километров в час. Запустите всё ещё раз. Во сколько раз изменился путь за пятый час? Как изменился наклон прямой?

Вторая. Перепишите задачу под свободное падение. Здесь и единицы другие — метры и секунды, — и сама формула: \(s = v_0 t + a t^2 / 2\). Возьмите начальную скорость \(v_0 = 0\) м/с, ускорение \(a = 10\) м/с² и постройте график для времени от 0 до 10 с. Какая фигура получилась? Почему теперь по вертикальной оси у нас метры, а не километры?

Третья. Поместите оба случая на один график: равномерное движение (скорость 20 м/с, формула \(s = v \cdot t\)) и равноускоренное (\(v_0 = 0\), \(a = 5\) м/с², формула \(s = a t^2 / 2\)). Время — от 0 до 10 секунд. Чтобы линии оказались на одних осях, вызовите plt.plot() два раза подряд, а plt.show() — уже после обоих вызовов. В какой момент пройденный путь сравняется?

§ 9. Итог: что мы теперь умеем¶

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

Переменная — это имя для величины: v = 20.
Присваивание — команда «запомни», а не уравнение.
Формула — вычислимое выражение, которое Python считает по правилам арифметики: s = v * t.
Функция — правило «вход → выход», записанное один раз и применимое сколько угодно раз: def path(v, t): return v * t.
Цикл for — многократное вычисление одной командой: for t in range(n): ....
Список — упорядоченный набор значений: ts = []; ts.append(t).
График — портрет зависимости одной величины от другой: plt.plot(ts, ss); plt.show().

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

§ 10. Что дальше: «Цифра в мире величин»¶

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

Помните сюрприз из самой первой подглавы? Сложили 0.1 и 0.2 — и не получили 0.3. Это не сбой и не недоразумение. Это фундаментальное свойство того, как числа живут в памяти машины. И чтобы по-настоящему его понять, придётся остановиться и спросить: а что вообще такое число?

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

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

В математике число — точный объект, который можно определять и преобразовывать без всякого прибора, и здесь \(0.1 + 0.2\) совершенно равно \(0.3\), без всяких лишних нулей в конце.

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

Три мира — три режима работы с числом. И все три нужно понимать, чтобы грамотно работать в STEM.

Об этом — следующая ключевая глава начального блока, «Цифра в мире величин». Там мы наконец и разберёмся, почему \(0.1 + 0.2 \neq 0.3\) и что с этим делать.

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

A R I S T O T E L

AI-powered STEM Education · aristotel.academy Модуль 0: Python — ваш рабочий инструмент · © 2026