Типы данных и переменные: фундамент хранения данных

Переменные: как давать имена данным и сохранять их в памяти

В прошлом курсе мы написали скрипт, который рассчитывал чистую прибыль от продажи подписок. Код выглядел так: print((50 * 1200) - 15000).

Пока формула состоит из трех чисел, всё понятно. Но представьте, что вам нужно использовать показатель выручки (50 * 1200) в пяти разных отчетах внутри одного скрипта. А завтра цена подписки изменится с 1200 руб. на 1500 руб. Вам придется вручную искать и исправлять это число по всему коду. Это долго, и в реальной аналитике, где строк кода тысячи, ошибка неизбежна.

Чтобы не работать с «голыми» числами, программисты используют переменные.

Что такое переменная

Переменная — это именованная область в памяти компьютера. Представьте себе пустую коробку. Вы кладете в нее число, закрываете и наклеиваете стикер с понятным названием (например, «цена»). Теперь, когда вам понадобится это число, вы не вспоминаете его наизусть, а просто обращаетесь к коробке по имени на стикере.

В Python создание переменной и сохранение в нее данных называется присваиванием. Для этого используется знак равенства =.

price = 1200
users = 50
expenses = 15000

Теперь интерпретатор запомнил: если в коде встречается слово price, вместо него нужно подставить число 1200. Мы можем переписать наш расчет прибыли так, чтобы он стал читаемым:

revenue = users * price
profit = revenue - expenses
print(profit)

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

Анатомия оператора присваивания

Главная ошибка начинающих — воспринимать знак = в коде как математическое равенство. В математике запись $x = 5$ означает факт: «икс равен пяти».

В программировании = — это команда к действию. Она читается не слева направо, а справа налево.

Когда интерпретатор видит строку revenue = 50 * 1200, он выполняет два шага в строгой последовательности:

1. Сначала он смотрит только на правую часть от знака =. Он выполняет все математические вычисления там (50 * 1200) и получает итоговый результат (60000).
2. Затем он смотрит на левую часть. Он берет полученный результат и кладет его в «коробку» с именем revenue.

Знак = в Python означает: «вычисли то, что справа, и сохрани под именем, которое слева».

Как правильно называть переменные

Интерпретатору всё равно, как вы назовете коробку с данными. Код a = 50 * 1200 сработает так же безупречно, как и revenue = 50 * 1200. Но код чаще читают люди, чем машины.

В мире Python существует стандарт оформления кода (PEP 8), который диктует правила именования.

Жесткие правила (если их нарушить, скрипт упадет с синтаксической ошибкой):

• Имя может состоять только из латинских букв, цифр и символа подчеркивания _.
• Имя не может начинаться с цифры (1user — нельзя, user1 — можно).
• Нельзя использовать пробелы (my price — ошибка, нужно my_price).

Правила хорошего тона (стиль snake_case): В Python принято писать имена переменных строчными (маленькими) буквами, а если имя состоит из нескольких слов, разделять их подчеркиванием. Этот стиль называется snake_case (змеиный регистр), потому что подчеркивания делают текст похожим на ползущую змею.

Плохо	Хорошо	Почему хорошо
x = 1200	price = 1200	Понятно, что именно хранит переменная.
UserCount = 50	user_count = 50	Соблюден стандарт snake_case (только строчные буквы и подчеркивания).
prc_sbscr = 1200	subscription_price = 1200	Нет излишних сокращений, слово читается легко.

Обновление значений в памяти

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

price = 1200
print(price)  # Выведет 1200

price = 1500
print(price)  # Выведет 1500 (старое значение забыто)

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

Допустим, у нас появился один новый пользователь. Как увеличить users на единицу?

users = 50
users = users + 1

С точки зрения математики уравнение $x = x + 1$ не имеет смысла. Но для Python это логичная команда:

1. Смотрим направо: users + 1. Текущее значение users равно 50. Значит, 50 + 1 = 51.
2. Смотрим налево: берем результат (51) и кладем его обратно в коробку users. Старое значение (50) стирается.

Мы научились сохранять числовые данные в памяти и давать им понятные имена. Но данные бывают разными. Цена — это целое число. А вот конверсия в покупку может быть равна 2.5%, а имя клиента — это вообще текст. В следующей главе мы разберем, как Python отличает целые числа от дробных и какие возможности это открывает для анализа данных.

Числовые типы: различие между целыми числами и числами с плавающей точкой

В аналитике данных мы постоянно считаем: количество уникальных пользователей за день, среднее время на сайте, конверсию в процентах, выручку в рублях. Для нас всё это — просто числа. Но если мы сохраним в переменные значения users = 150 и conversion = 2.5, интерпретатор Python выделит под них память совершенно по-разному.

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

Два мира чисел: int и float

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

Целые числа (Integer, или int) Это числа без дробной части: положительные, отрицательные и ноль. Они используются для подсчета неделимых объектов. Нельзя иметь полтора зарегистрированных пользователя или совершить 3.7 клика по кнопке.

Примеры в коде: 100, -5, 0.

Числа с плавающей точкой (Floating-point, или float) Это числа, имеющие дробную часть. Они нужны для измерений: вес, расстояние, деньги, средние показатели. Название «с плавающей точкой» исторически связано с тем, как процессор кодирует такие числа: он хранит значащие цифры и отдельно — позицию запятой (точки), которая может «плавать» влево или вправо.

Примеры в коде: 3.14, -0.001, 150.0.

Обратите внимание на последний пример: 150.0. С точки зрения математики $150 = 150.0$. Но для Python наличие точки — это строгий сигнал создать объект типа float. Точка — главный визуальный маркер дробного числа в коде.

Как узнать тип переменной: функция type()

Когда мы смотрим на код x = 5, мы легко понимаем, что перед нами целое число. Но когда данные приходят из внешнего файла или являются результатом сложной формулы, визуально определить тип невозможно.

Для этого в Python есть встроенный инструмент — функция type(). Она работает как сканер: вы передаете ей значение или переменную, а она возвращает её внутренний тип.

Чтобы увидеть результат на экране, обернем type() в уже знакомую нам функцию вывода print():

users = 100
average_check = 450.50

print(type(users))
print(type(average_check))
print(type(10.0))

Результат выполнения этого скрипта будет выглядеть так:

<class 'int'>
<class 'float'>
<class 'float'>

Слово class здесь означает категорию (тип) объекта. Мы видим, что 10.0 безошибочно распознается как float именно благодаря точке.

Взаимодействие типов: эффект заражения

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

Что произойдет, если мы смешаем int и float в одной математической операции?

subscribers = 10       # int
price = 199.99         # float

total_revenue = subscribers * price
print(total_revenue)
print(type(total_revenue))

Результат:

1999.9
<class 'float'>

Срабатывает правило: если в математической операции участвует хотя бы один float, результат всегда будет float. Интерпретатор автоматически «повышает» тип целого числа до дробного перед вычислением ($10$ временно превращается в $10.0$). Это сделано для защиты от потери данных — чтобы случайно не отбросить копейки при расчете денег.

Почему деление — особенное

Вспомним работу арифметических операторов. Сложение, вычитание и умножение двух целых чисел всегда дают целое число: $5 \times 2 = 10$ (тип int).

Но обычное деление (/) ведет себя иначе:

total_users = 100
groups = 2

users_per_group = total_users / groups
print(users_per_group)
print(type(users_per_group))

Результат:

50.0
<class 'float'>

Даже если числа делятся нацело, без остатка, оператор / всегда возвращает float. Создатели Python приняли это решение, потому что результат деления непредсказуем: $10 / 2$ делится нацело, а $10 / 3$ — нет. Чтобы тип результата не прыгал непредсказуемо в зависимости от входных данных, обычное деление стандартизировано под float.

Если же вам принципиально нужно получить целое число при делении (например, чтобы узнать, сколько полных недель в 30 днях), используется оператор целочисленного деления //, который отбрасывает дробную часть и возвращает int.

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

Строки и текстовые данные: методы манипуляции и форматирования

Числа позволяют нам считать выручку и метрики, но данные редко состоят только из цифр. У нас есть имена клиентов, их email-адреса, статусы заказов, названия городов и UTM-метки. Чтобы сохранить «Иван» или «anna@example.com», целые числа и числа с плавающей точкой не подойдут. Компьютеру нужно явно указать, что перед ним текст, который нужно воспринимать буквально, буква за буквой.

Создание строк: кавычки и тип str

Текстовые данные в Python называются строками (от английского string). Чтобы интерпретатор понял, что перед ним строка, а не имя переменной или команда, текст необходимо заключить в кавычки.

В Python можно использовать как одинарные, так и двойные кавычки — они работают абсолютно одинаково.

client_name = 'Алексей'
order_status = "Доставлен"

Зачем нужны два вида кавычек? Это решает проблему, когда кавычка является частью самого текста. Если вам нужно написать слово с апострофом или прямую речь, вы просто оборачиваете строку в кавычки другого типа:

# Двойные кавычки снаружи позволяют использовать одинарные внутри
company_name = "ООО 'Ромашка'"

# Одинарные кавычки снаружи позволяют использовать двойные внутри
message = 'Система выдала статус "Ошибка сервера"'

Любые данные, помещенные в кавычки, становятся строкой. Даже если внутри написаны только цифры, для Python это больше не математический объект. Встроенная функция type(), с которой мы работали ранее, покажет для них тип str:

metric_value = "1500"
print(type(metric_value))  # Выведет <class 'str'>

Математика для текста: конкатенация и дублирование

К строкам можно применять некоторые математические операторы, но их поведение кардинально меняется.

Оператор сложения + склеивает две строки вместе. Этот процесс называется конкатенацией.

first_name = "Иван"
last_name = "Иванов"
full_name = first_name + " " + last_name
print(full_name)  # Выведет: Иван Иванов

Обратите внимание: Python склеивает строки в точности так, как вы указали. Он не добавит пробел автоматически, поэтому нам пришлось явно прибавить строку с пробелом " ".

Оператор умножения * позволяет продублировать строку заданное количество раз (умножать можно только строку на целое число int):

divider = "-" * 20
print(divider)  # Выведет: --------------------

Понимание того, что строка — это просто набор символов, критически важно при работе с числами в кавычках.

Методы строк: встроенные инструменты очистки

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

У типа str есть встроенные инструменты для изменения текста — методы.

Метод — это функция, которая «привязана» к конкретному типу данных и умеет работать именно с ним.

Методы вызываются через точку после имени переменной или самой строки: переменная.метод(). Вот четыре основных метода для подготовки текстовых данных:

1. .lower() — переводит все буквы в нижний регистр. Полезно для email-адресов.
2. .upper() — переводит все буквы в верхний регистр. Часто используется для промокодов и аббревиатур.
3. .strip() — удаляет невидимые символы (пробелы, переносы строк) в начале и в конце строки.
4. .replace(что_заменить, на_что_заменить) — находит фрагмент текста и заменяет его на другой.

Пример очистки данных:

raw_email = "   Admin@EXAMPLE.com   "

# 1. Убираем лишние пробелы по краям
clean_spaces = raw_email.strip()  # "Admin@EXAMPLE.com"

# 2. Переводим в нижний регистр
final_email = clean_spaces.lower() # "admin@example.com"

Python позволяет вызывать методы по цепочке, один за другим, выполняя операции слева направо:

raw_email = "   Admin@EXAMPLE.com   "
final_email = raw_email.strip().lower()

F-строки: сборка отчетов и сообщений

Мы умеем сохранять числа и очищать текст. Главная задача аналитика или разработчика — собрать эти данные воедино и вывести понятный результат.

Использовать конкатенацию (+) для сборки длинных предложений из разных переменных неудобно. Более того, Python не позволит сложить строку str и число int напрямую — он выдаст ошибку, так как не понимает, нужно ли математически сложить значения или склеить текст.

Для элегантного решения этой задачи в Python существуют f-строки (форматированные строки).

Чтобы превратить обычную строку в f-строку, нужно поставить английскую букву f перед первой кавычкой. После этого вы можете вставлять любые переменные прямо внутрь текста, оборачивая их в фигурные скобки {}.

user_name = "Мария"
purchases_count = 5
total_spent = 12500.50

# Сборка отчета с помощью f-строки
report = f"Клиент {user_name} совершил {purchases_count} покупок на сумму {total_spent} руб."

print(report)
# Выведет: Клиент Мария совершил 5 покупок на сумму 12500.5 руб.

Внутри фигурных скобок f-строки Python автоматически берет значение переменной, безопасно превращает его в текст (даже если это int или float) и подставляет в итоговое предложение.

Синтез: от сырых данных к готовому результату

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

# 1. Входящие сырые данные
raw_name = "   иВАН   "
raw_city = "москва"
orders = 3

# 2. Очистка и форматирование текста
clean_name = raw_name.strip().lower().replace("иван", "Иван")
clean_city = raw_city.upper()

# 3. Формирование итогового сообщения
log_message = f"[{clean_city}] Пользователь {clean_name} оформил заказ №{orders + 1}."

print(log_message)
# Выведет: [МОСКВА] Пользователь Иван оформил заказ №4.

Обратите внимание на фигурные скобки {orders + 1}. Внутри f-строк можно не только указывать имена переменных, но и выполнять простые математические вычисления прямо на лету.

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

Динамическая типизация и преобразование типов данных

Представьте, что вы выгрузили из базы данных стоимость товара. Вы очистили текст от лишних пробелов с помощью метода .strip() и получили идеальную, казалось бы, строку: price = "250". Теперь вам нужно рассчитать налог — 20% от этой суммы.

Вы пишете tax = price * 0.2 и запускаете код. Вместо ожидаемых 50 интерпретатор выдает красную ошибку: TypeError: can't multiply sequence by non-int of type 'float'.

Почему так произошло? Для нас "250" — это число двести пятьдесят. Но для Python это просто набор текстовых символов: двойка, пятерка и ноль. Умножать текст на дробное число бессмысленно. Чтобы математика заработала, нам нужно научиться переводить данные из одного состояния в другое.

Явное преобразование типов (Casting)

Мы уже знаем встроенную функцию type(), которая позволяет узнать тип данных. В Python есть похожие по написанию функции, которые не просто называют тип, а превращают данные в этот тип. Это называется явным преобразованием.

Три главные функции для преобразования:

• int() — пытается превратить данные в целое число.
• float() — пытается превратить данные в число с плавающей точкой.
• str() — превращает любые данные в строку.

Посмотрим, как это решает проблему с расчетом налога:

raw_price = "250"             # Это строка (str)
clean_price = int(raw_price)  # Теперь это число 250 (int)

tax = clean_price * 0.2       # Математика работает!
print(f"Налог составит: {tax} руб.")

Преобразование работает и в обратную сторону. Хотя для сборки текста мы чаще используем f-строки, иногда нужно явно превратить число в текст, чтобы, например, склеить его с другой строкой через символ +:

error_code = 404
message = "Ошибка номер " + str(error_code)

Границы возможного: когда преобразование ломается

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

# Успешно: внутри строки только цифры
users = int("1054")

# Ошибка ValueError: Python не знает, что делать с буквами
revenue = int("1000 USD")

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

Динамическая типизация: переменные как ярлыки

В предыдущем примере мы создали две разные переменные: raw_price для текста и clean_price для числа. Но обязательно ли плодить новые имена на каждом шаге?

В некоторых языках программирования (например, в C++ или Java) переменная — это жесткая коробка. Если вы создали коробку для целых чисел, положить в нее текст уже нельзя. Это называется статической типизацией.

Python работает иначе. В нем используется динамическая типизация. Переменная в Python — это не коробка, а бейджик или стикер с именем, который вы приклеиваете к данным. Сами данные (числа, строки) хранятся в памяти и имеют строгий тип. А вот переменная-ярлык типа не имеет, она просто указывает на объект.

Благодаря динамической типизации, мы можем взять уже существующий ярлык и переклеить его на новый объект другого типа. Это позволяет писать очень лаконичный код, обновляя переменную «через саму себя»:

discount = "  15  "       # Ярлык discount указывает на строку
discount = discount.strip() # Ярлык переклеивается на очищенную строку "15"
discount = int(discount)    # Ярлык переклеивается на число 15 (int)

Интерпретатор выполняет этот код шаг за шагом:

1. Вычисляет выражение справа от знака =. Берет строку " 15 ", очищает ее, получает новую строку "15".
2. Затем берет эту строку "15", передает в функцию int() и создает в памяти число 15.
3. В самом конце берет ярлык discount и привязывает его к этому новому числу.

Старая строка со всеми пробелами просто исчезает из памяти за ненадобностью.

Собираем конвейер обработки данных

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

Рассмотрим реальный сценарий. Из системы аналитики пришло значение конверсии в виде неаккуратной строки. Нам нужно рассчитать, сколько реальных покупателей мы получим из 5000 посетителей.

visitors = 5000
conversion_rate = " 2.5% "

# Шаг 1: Очистка текста (убираем пробелы и знак процента)
conversion_rate = conversion_rate.strip()
conversion_rate = conversion_rate.replace("%", "")
# Сейчас conversion_rate указывает на строку "2.5"

# Шаг 2: Преобразование типа
conversion_rate = float(conversion_rate)
# Теперь conversion_rate указывает на дробное число 2.5

# Шаг 3: Математика (переводим проценты в доли и умножаем)
buyers = visitors * (conversion_rate / 100)

print(f"Ожидаемое количество покупателей: {int(buyers)}")

Обратите внимание на последнюю строку. В результате расчетов buyers стал числом с плавающей точкой (так как в формуле было деление). Но полтора землекопа или 125.0 покупателей выглядят в отчете странно. Поэтому прямо внутри f-строки мы использовали int(buyers), чтобы отбросить дробную часть и вывести красивое целое число.

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

Ввод данных пользователем и подготовка переменных для отчетов

До сих пор наши программы напоминали калькуляторы с намертво приклеенными кнопками. Мы писали users = 150, запускали скрипт, и он всегда считал метрики именно для 150 пользователей. Чтобы рассчитать данные для 200 пользователей, приходилось открывать исходный код и переписывать значения вручную. Это неудобно для программиста и совершенно неприемлемо для конечного пользователя программы, у которого вообще нет доступа к коду.

Настоящая автоматизация начинается там, где скрипт умеет запрашивать данные у внешнего мира в момент своей работы, адаптируясь под новые вводные без изменения самого кода.

Диалог с программой: функция input()

Чтобы скрипт мог задать вопрос и дождаться ответа с клавиатуры, используется встроенная функция input(). В скобках ей передается строка-подсказка (prompt) — текст, который увидит пользователь.

name = input("Введите имя клиента: ")
print(f"Отчет для клиента: {name}")

Когда интерпретатор доходит до строки с input(), происходит важное изменение в потоке выполнения: программа ставится на паузу. Она замирает и ждет, пока пользователь напечатает текст в консоли и нажмет клавишу Enter. Как только Enter нажат, введенный текст отправляется в правую часть выражения и через оператор присваивания = сохраняется в переменную слева.

Главная ловушка ввода: всё есть текст

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

age = input("Сколько вам лет? ")
next_age = age + 1

Если вы запустите этот код и введете число 25, программа завершится с ошибкой TypeError. Почему?

Функция input() всегда возвращает данные в виде строки (тип str), независимо от того, что ввел пользователь.

Даже если вы набрали на клавиатуре цифры, для Python это не математическое число, а просто набор текстовых символов "25". В предыдущих главах мы выяснили, что Python не умеет складывать текст с числами. Попытка выполнить "25" + 1 обречена на провал.

Если же мы попробуем сложить два значения, полученных через input(), ошибки не будет, но результат вас удивит:

revenue = input("Введите выручку: ")  # пользователь вводит 100
bonus = input("Введите бонус: ")      # пользователь вводит 50
total = revenue + bonus
print(total) # Выведет 10050, а не 150!

Поскольку обе переменные хранят строки, сработала конкатенация — склеивание текста. Python просто приставил "50" к "100".

Конвейер подготовки данных

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

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

Допустим, мы просим менеджера ввести сумму расходов, а он вводит: " 1500.50 руб. ". Нам нужно превратить это в чистое число с плавающей точкой 1500.50 (тип float).

Шаг 1. Получаем сырую строку

raw_data = input("Введите расходы: ") # "  1500.50 руб.  "

Шаг 2. Очищаем от мусора Используем методы строк .replace() для удаления слова "руб." и .strip() для отсечения пробелов по краям. Благодаря тому, что методы возвращают новую строку, мы можем вызывать их по цепочке:

clean_text = raw_data.replace("руб.", "").strip() # Получаем "1500.50"

Шаг 3. Конвертируем в число Теперь, когда в строке остались только цифры и точка, мы можем безопасно применить функцию float():

expenses = float(clean_text) # Получаем число 1500.50 (тип float)

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

expenses = input("Введите расходы: ")
expenses = expenses.replace("руб.", "").strip()
expenses = float(expenses)

Финальная сборка: интерактивный генератор отчета

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

Соберем полноценный скрипт, который запрашивает данные у пользователя, обрабатывает их и выдает бизнес-метрику — рентабельность (отношение прибыли к выручке, выраженное в процентах).

# 1. Сбор данных
company_name = input("Название компании: ")
company_name = company_name.strip().upper() # Очищаем пробелы и делаем заглавными

raw_revenue = input("Выручка (в USD): ")
raw_expenses = input("Расходы (в USD): ")

# 2. Очистка и конвертация (предполагаем, что пользователь мог написать "USD")
revenue = float(raw_revenue.replace("USD", "").strip())
expenses = float(raw_expenses.replace("USD", "").strip())

# 3. Бизнес-логика (расчеты)
profit = revenue - expenses
margin = (profit / revenue) * 100

# 4. Формирование отчета
print(f"--- ОТЧЕТ: {company_name} ---")
print(f"Выручка: {revenue} USD")
print(f"Расходы: {expenses} USD")
print(f"Чистая прибыль: {profit} USD")
print(f"Рентабельность: {margin} %")

Запустив этот скрипт, мы получаем универсальную программу. Сегодня она посчитает метрики для кофейни, завтра — для IT-стартапа. Мы отделили логику программы (код) от ее данных (ввод пользователя). Это фундаментальный принцип разработки любого программного обеспечения, от простых скриптов до сложных веб-приложений.