Математика в Python-программировании: ключ к эффективным алгоритмам

# Полином: f(x) = 3x^2 + 2x + 5
def polynomial(x):
return 3 * x**2 + 2 * x + 5

# Вычисление для x = 4
result = polynomial(4) # 3*16 + 2*4 + 5 = 48 + 8 + 5 = 61
print(result) # 61

# Линейная функция: y = mx + b
def linear_function(x, m=2, b=1):
return m * x + b

# Применение к списку значений
values = [1, 2, 3, 4, 5]
results = [linear_function(x) for x in values]
print(results) # [3, 5, 7, 9, 11]

import numpy as np

# Система уравнений:
# 2x + y = 5
# 3x + 2y = 8

# Матрица коэффициентов
A = np.array([[2, 1], [3, 2]])
# Вектор правых частей
b = np.array([5, 8])

# Решение системы
solution = np.linalg.solve(A, b)
print(f"x = {solution[0]}, y = {solution[1]}") # x = 2.0, y = 1.0

import math

# Вычисление натурального логарифма
ln_value = math.log(10) # ln(10) ≈ 2.302585...

# Экспоненциальная функция
exp_value = math.exp(2) # e^2 ≈ 7.389056...

# Логарифм по основанию 2 (часто используется в анализе алгоритмов)
log2_value = math.log2(8) # log₂(8) = 3

import numpy as np

# Создание массива
arr = np.array([1, 2, 3, 4, 5])

# Векторизованные операции
print(arr * 2) # [2 4 6 8 10]

# Создание многомерного массива (матрицы)
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Матричное умножение
result = matrix @ matrix # или np.matmul(matrix, matrix)
print(result)
# [[ 30 36 42]
# [ 66 81 96]
# [102 126 150]]

import numpy as np
from scipy import optimize, stats, integrate

# Нахождение корней уравнения f(x) = x^2 – 4
def f(x):
return x**2 – 4

root = optimize.root(f, x0=1)
print(root.x) # [2\.]

# Статистические тесты
data = np.random.normal(size=100)
shapiro_test = stats.shapiro(data)
print(f"Shapiro-Wilk тест нормальности: p-value = {shapiro_test.pvalue:.6f}")

# Численное интегрирование
def integrand(x):
return x**2

integral, error = integrate.quad(integrand, 0, 1)
print(f"∫x² dx от 0 до 1 = {integral}") # Должно быть 1/3

import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt

# Генерация зашумлённых данных
x = np.linspace(0, 10, 100)
y_true = 3 * np.exp(-0.5 * x) + 2
y_noisy = y_true + 0.5 * np.random.normal(size=len(x))

# Функция для аппроксимации
def exp_decay(x, a, b, c):
return a * np.exp(-b * x) + c

# Аппроксимация
params, covariance = curve_fit(exp_decay, x, y_noisy, p0=[3, 0.5, 2])
a_fit, b_fit, c_fit = params

print(f"Аппроксимация: y = {a_fit:.2f} * exp(-{b_fit:.2f} * x) + {c_fit:.2f}")
print(f"Истинные значения: y = 3 * exp(-0.5 * x) + 2")

# Визуализация результатов с помощью matplotlib
y_fit = exp_decay(x, a_fit, b_fit, c_fit)
plt.scatter(x, y_noisy, label='Зашумлённые данные')
plt.plot(x, y_fit, 'r-', label='Аппроксимация')
plt.plot(x, y_true, 'g--', label='Истинная функция')
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('Аппроксимация экспоненциального спада')
plt.show()

import numpy as np

# Генерация случайной выборки
data = np.random.normal(loc=100, scale=15, size=1000)

# Базовая статистика
mean = np.mean(data)
median = np.median(data)
std_dev = np.std(data)
variance = np.var(data)
minimum = np.min(data)
maximum = np.max(data)
percentile_25 = np.percentile(data, 25)
percentile_75 = np.percentile(data, 75)

print(f"Среднее: {mean:.2f}")
print(f"Медиана: {median:.2f}")
print(f"Стандартное отклонение: {std_dev:.2f}")
print(f"Дисперсия: {variance:.2f}")
print(f"Минимум: {minimum:.2f}")
print(f"Максимум: {maximum:.2f}")
print(f"25-й процентиль: {percentile_25:.2f}")
print(f"75-й процентиль: {percentile_75:.2f}")

from scipy import stats

# Проверка нормальности распределения (критерий Шапиро-Уилка)
shapiro_test = stats.shapiro(data)
print(f"Тест Шапиро-Уилка: p-value = {shapiro_test.pvalue:.6f}")

# Если p-value > 0.05, обычно считают, что распределение не отличается от нормального
if shapiro_test.pvalue > 0.05:
print("Распределение можно считать нормальным")
else:
print("Распределение существенно отличается от нормального")

# t-тест для проверки гипотезы о среднем значении
t_test = stats.ttest_1samp(data, 100) # Проверяем гипотезу, что среднее равно 100
print(f"t-тест: p-value = {t_test.pvalue:.6f}")

# Корреляция Пирсона
x = np.random.normal(size=100)
y = 2 * x + np.random.normal(size=100) # y коррелирует с x
correlation, p_value = stats.pearsonr(x, y)
print(f"Корреляция Пирсона: r = {correlation:.4f}, p-value = {p_value:.6f}")

import matplotlib.pyplot as plt
import seaborn as sns

# Настройка стиля Seaborn
sns.set(style="whitegrid")

# Гистограмма с наложением теоретической плотности нормального распределения
plt.figure(figsize=(10, 6))
sns.histplot(data, bins=30, kde=True)
plt.title("Распределение данных с наложением кривой плотности")
plt.xlabel("Значение")
plt.ylabel("Частота")
plt.axvline(mean, color='r', linestyle='--', label=f"Среднее = {mean:.2f}")
plt.axvline(median, color='g', linestyle='-', label=f"Медиана = {median:.2f}")
plt.legend()
plt.show()

# QQ-plot для проверки нормальности
plt.figure(figsize=(10, 6))
stats.probplot(data, plot=plt)
plt.title("Квантильный график для проверки нормальности")
plt.show()

# Моделирование результатов A/B-теста
# Группа A: старый дизайн, конверсия примерно 5%
# Группа B: новый дизайн, конверсия примерно 7%

np.random.seed(42)
sample_size = 1000

# Генерация данных
group_a = np.random.binomial(1, 0.05, sample_size)
group_b = np.random.binomial(1, 0.07, sample_size)

# Вычисление конверсий
conv_a = group_a.mean()
conv_b = group_b.mean()

print(f"Конверсия в группе A: {conv_a:.2%}")
print(f"Конверсия в группе B: {conv_b:.2%}")
print(f"Абсолютное улучшение: {(conv_b – conv_a):.2%}")
print(f"Относительное улучшение: {(conv_b – conv_a) / conv_a:.2%}")

# Статистическая значимость различий
z_test = stats.ttest_ind(group_a, group_b, equal_var=False)
print(f"p-value: {z_test.pvalue:.6f}")

if z_test.pvalue < 0.05:
print("Различие статистически значимо (95% уверенности)")
else:
print("Недостаточно доказательств для утверждения о значимом различии")

# Простой пример байесовского обновления
# Предположим, мы оцениваем вероятность того, что монета нечестная

from scipy import stats

# Априорное распределение (beta-распределение)
# Параметры: alpha=1, beta=1 (равномерное распределение)
prior_alpha = 1
prior_beta = 1

# Данные: 8 орлов и 2 решки из 10 бросков
heads = 8
tails = 2
total = heads + tails

# Апостериорное распределение
posterior_alpha = prior_alpha + heads
posterior_beta = prior_beta + tails

# Генерация точек для графика
x = np.linspace(0, 1, 100)
prior_pdf = stats.beta.pdf(x, prior_alpha, prior_beta)
posterior_pdf = stats.beta.pdf(x, posterior_alpha, posterior_beta)

# Точечная оценка (ожидаемое значение апостериорного распределения)
point_estimate = posterior_alpha / (posterior_alpha + posterior_beta)
print(f"Байесовская оценка вероятности выпадения орла: {point_estimate:.4f}")

# 95% доверительный интервал
credible_interval = stats.beta.interval(0.95, posterior_alpha, posterior_beta)
print(f"95% доверительный интервал: [{credible_interval[0]:.4f}, {credible_interval[1]:.4f}]")

# Визуализация
plt.figure(figsize=(10, 6))
plt.plot(x, prior_pdf, label='Априорное распределение')
plt.plot(x, posterior_pdf, label='Апостериорное распределение')
plt.axvline(point_estimate, color='r', linestyle='--', label=f'Точечная оценка: {point_estimate:.4f}')
plt.fill_between(x, 0, posterior_pdf, where=(x >= credible_interval[0]) & (x <= credible_interval[1]), 
alpha=0.3, color='green', label='95% доверительный интервал')
plt.xlabel('Вероятность выпадения орла')
plt.ylabel('Плотность вероятности')
plt.title('Байесовское обновление для вероятности нечестной монеты')
plt.legend()
plt.grid(True)
plt.show()

# Множества в Python
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Операции над множествами
union = A | B # Объединение
intersection = A & B # Пересечение
difference = A – B # Разность
symmetric_difference = A ^ B # Симметрическая разность

print(f"A ∪ B = {union}")
print(f"A ∩ B = {intersection}")
print(f"A \\ B = {difference}")
print(f"A △ B = {symmetric_difference}")

# Проверка включения
subset_check = {1, 2}.issubset(A)
print(f"{{1, 2}} ⊆ A: {subset_check}")

# Булева алгебра
p = True
q = False

# Основные операции
conjunction = p and q # Конъюнкция (AND)
disjunction = p or q # Дизъюнкция (OR)
negation = not p # Отрицание (NOT)
implication = (not p) or q # Импликация (IF-THEN)
equivalence = p == q # Эквивалентность (IF AND ONLY IF)

print(f"p ∧ q = {conjunction}")
print(f"p ∨ q = {disjunction}")
print(f"¬p = {negation}")
print(f"p → q = {implication}")
print(f"p ↔ q = {equivalence}")

# Таблицы истинности
def truth_table(operation, operator_symbol):
print(f"\nТаблица истинности для {operator_symbol}")
print(f"p\tq\t{operator_symbol}")
print("-" * 20)
for p in [True, False]:
for q in [True, False]:
result = operation(p, q)
print(f"{p}\t{q}\t{result}")

# Примеры таблиц истинности
truth_table(lambda p, q: p and q, "p ∧ q")
truth_table(lambda p, q: p or q, "p ∨ q")

from itertools import permutations, combinations, combinations_with_replacement, product

# Множество для примеров
elements = {1, 2, 3, 4}

# Размещения (все возможные порядки элементов)
perms = list(permutations(elements, 2))
print(f"Размещения из {elements} по 2: {len(perms)} вариантов")
for p in list(perms)[:5]: # Выводим первые 5 для краткости
print(p)

# Сочетания (уникальные неупорядоченные подмножества)
combs = list(combinations(elements, 2))
print(f"\nСочетания из {elements} по 2: {len(combs)} вариантов")
for c in combs:
print(c)

# Сочетания с повторениями
comb_replace = list(combinations_with_replacement(elements, 2))
print(f"\nСочетания с повторениями из {elements} по 2: {len(comb_replace)} вариантов")
for cr in comb_replace:
print(cr)

# Декартово произведение
cart_prod = list(product(elements, repeat=2))
print(f"\nДекартово произведение {elements} × {elements}: {len(cart_prod)} вариантов")
for cp in list(cart_prod)[:5]: # Выводим первые 5 для краткости
print(cp)

import networkx as nx
import matplotlib.pyplot as plt

# Создание графа
G = nx.Graph()

# Добавление узлов
cities = ["Москва", "Санкт-Петербург", "Казань", "Новосибирск", "Екатеринбург"]
G.add_nodes_from(cities)

# Добавление рёбер (расстояния в км, приблизительно)
edges = [
("Москва", "Санкт-Петербург", 650),
("Москва", "Казань", 800),
("Москва", "Екатеринбург", 1600),
("Санкт-Петербург", "Новосибирск", 3200),
("Казань", "Екатеринбург", 900),
("Екатеринбург", "Новосибирск", 1500)
]

G.add_weighted_edges_from([(u, v, w) for u, v, w in edges])

# Визуализация графа
plt.figure(figsize=(10, 8))
pos = nx.spring_layout(G) # Алгоритм размещения узлов
edge_labels = {(u, v): d["weight"] for u, v, d in G.edges(data=True)}
nx.draw(G, pos, with_labels=True, node_color="skyblue", node_size=3000, font_size=10, font_weight="bold")
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
plt.title("Карта расстояний между городами")
plt.show()

# Алгоритм поиска кратчайшего пути (алгоритм Дейкстры)
shortest_path = nx.dijkstra_path(G, "Москва", "Новосибирск")
shortest_path_length = nx.dijkstra_path_length(G, "Москва", "Новосибирск")

print(f"Кратчайший путь из Москвы в Новосибирск: {' -> '.join(shortest_path)}")
print(f"Общая длина пути: {shortest_path_length} км")

# Центральность узлов
centrality = nx.betweenness_centrality(G)
print("\nЦентральность узлов (важность в сети):")
for city, score in sorted(centrality.items(), key=lambda x: x[1], reverse=True):
print(f"{city}: {score:.4f}")

# Поиск в ширину (BFS)
def bfs(graph, start):
visited = set([start])
queue = [start]

while queue:
vertex = queue.pop(0)
print(vertex, end=' ')

# Для всех соседей текущей вершины
for neighbour in graph[vertex]:
if neighbour not in visited:
visited.add(neighbour)
queue.append(neighbour)

# Поиск в глубину (DFS)
def dfs(graph, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
print(start, end=' ')

for neighbour in graph[start]:
if neighbour not in visited:
dfs(graph, neighbour, visited)

# Пример графа в виде словаря смежности
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}

print("BFS, начиная с вершины 'A':", end=' ')
bfs(graph, 'A')
print("\nDFS, начиная с вершины 'A':", end=' ')
dfs(graph, 'A')

# Рекурсивное вычисление факториала
def factorial(n):
if n <= 1:
return 1
else:
return n * factorial(n-1)

# Числа Фибоначчи (наивная реализация)
def fibonacci_naive(n):
if n <= 1:
return n
else:
return fibonacci_naive(n-1) + fibonacci_naive(n-2)

# Числа Фибоначчи (с мемоизацией для оптимизации)
def fibonacci_memo(n, memo={}):
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)
return memo[n]

# Сравнение производительности
import time

n = 30
print(f"Факториал {n} = {factorial(n)}")

start = time.time()
fib_naive = fibonacci_naive(n)
end = time.time()
print(f"Fibonacci({n}) = {fib_naive} (наивная реализация: {end-start:.6f} сек)")

start = time.time()
fib_memo = fibonacci_memo(n)
end = time.time()
print(f"Fibonacci({n}) = {fib_memo} (с мемоизацией: {end-start:.6f} сек)")

import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt

# Функция для минимизации
def objective(x):
return x**2 + 10*np.sin(x)

# Поиск минимума
x = np.linspace(-10, 10, 1000)
y = objective(x)

# Визуализация функции
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-')
plt.grid(True)
plt.xlabel('x')
plt.ylabel('f(x) = x² + 10sin(x)')
plt.title('Визуализация функции для минимизации')

# Поиск глобального минимума
result = optimize.minimize_scalar(objective, method='bounded', bounds=(-10, 10))
print(f"Глобальный минимум: x = {result.x:.4f}, f(x) = {result.fun:.4f}")

# Отметка минимума на графике
plt.plot(result.x, result.fun, 'ro', markersize=10)
plt.annotate(f'Min: ({result.x:.2f}, {result.fun:.2f})', 
xy=(result.x, result.fun), xytext=(result.x+1, result.fun+5),
arrowprops=dict(facecolor='black', shrink=0.05))

plt.show()

# Функция Розенброка (классическая тестовая функция оптимизации)
def rosenbrock(x):
return 100 * (x[1] – x[0]**2)**2 + (1 – x[0])**2

# Начальное приближение
initial_guess = np.array([-1.0, 1.0])

# Оптимизация методом Нелдера-Мида (симплекс-метод)
result = optimize.minimize(rosenbrock, initial_guess, method='Nelder-Mead')
print(f"Оптимизация методом Нелдера-Мида:")
print(f" x* = {result.x}")
print(f" f(x*) = {result.fun}")
print(f" Итераций: {result.nit}")
print(f" Статус: {result.message}")

# Оптимизация методом BFGS (квази-ньютоновский метод)
result_bfgs = optimize.minimize(rosenbrock, initial_guess, method='BFGS')
print(f"\nОптимизация методом BFGS:")
print(f" x* = {result_bfgs.x}")
print(f" f(x*) = {result_bfgs.fun}")
print(f" Итераций: {result_bfgs.nit}")
print(f" Статус: {result_bfgs.message}")

from scipy.optimize import linprog

# Задача линейного программирования:
# Максимизировать z = 3x + 4y при ограничениях:
# x + 2y <= 14
# 3x – y >= 0
# x – y <= 2
# x, y >= 0

# Для минимизации меняем знаки целевой функции
c = [-3, -4] # Целевая функция (коэффициенты)

# Ограничения в форме неравенств A_ub @ x <= b_ub
A_ub = [
[1, 2], # x + 2y <= 14
[-3, 1], # 3x – y >= 0 => -3x + y <= 0
[1, -1] # x – y <= 2
]
b_ub = [14, 0, 2]

# Решение задачи
result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(0, None))

print(f"Оптимальное решение:")
print(f" x = {result.x[0]:.4f}")
print(f" y = {result.x[1]:.4f}")
print(f" Максимальное значение z = {-result.fun:.4f}") # Меняем знак обратно
print(f" Статус: {result.message}")

# Визуализация решения
x = np.linspace(0, 10, 1000)

# Ограничения
y1 = (14 – x) / 2 # x + 2y <= 14
y2 = 3 * x # 3x – y >= 0
y3 = x – 2 # x – y <= 2

# Допустимая область
plt.figure(figsize=(10, 6))
plt.plot(x, y1, 'r-', label='x + 2y = 14')
plt.plot(x, y2, 'g-', label='3x – y = 0')
plt.plot(x, y3, 'b-', label='x – y = 2')

plt.fill_between(x, np.maximum(0, np.maximum(y2, y3)), y1, where=(x <= 7) & (y1 >= 0) & (y1 >= y2) & (y1 >= y3), 
alpha=0.3, color='gray')

# Отметка оптимального решения
plt.plot(result.x[0], result.x[1], 'ro', markersize=10)
plt.annotate(f'Оптимум: ({result.x[0]:.2f}, {result.x[1]:.2f})',
xy=(result.x[0], result.x[1]), xytext=(result.x[0]-1, result.x[1]+2),
arrowprops=dict(facecolor='black', shrink=0.05))

plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Визуализация задачи линейного программирования')
plt.legend()
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.show()

# Задача условной оптимизации: найти минимум функции с нелинейными ограничениями
def objective(x):
return x[0]**2 + x[1]**2

# Ограничение: x[0]**2 + x[1]**2 >= 1 (окружность)
def constraint(x):
return x[0]**2 + x[1]**2 – 1

# Начальное приближение
x0 = [2\.0, 2.0]

# Определение ограничений для scipy.optimize.minimize
cons = {'type': 'ineq', 'fun': constraint}

# Решение задачи методом SLSQP
result = optimize.minimize(objective, x0, method='SLSQP', constraints=cons)

print(f"Результат условной оптимизации:")
print(f" x* = {result.x}")
print(f" f(x*) = {result.fun}")
print(f" Успешно: {result.success}")
print(f" Статус: {result.message}")

# Визуализация решения
theta = np.linspace(0, 2*np.pi, 100)
x_circle = np.cos(theta)
y_circle = np.sin(theta)

plt.figure(figsize=(8, 8))
plt.plot(x_circle, y_circle, 'r-', label='Ограничение: x² + y² = 1')

# Отметка оптимального решения
plt.plot(result.x[0], result.x[1], 'bo', markersize=10)
plt.annotate(f'Оптимум: ({result.x[0]:.2f}, {result.x[1]:.2f})',
xy=(result.x[0], result.x[1]), xytext=(result.x[0]+0.5, result.x[1]+0.5),
arrowprops=dict(facecolor='black', shrink=0.05))

# Контурный график целевой функции
x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2

plt.contour(X, Y, Z, levels=np.arange(0, 5, 0.5), alpha=0.6)
plt.colorbar(label='Значение целевой функции')

plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Условная оптимизация: минимизация x² + y² при x² + y² >= 1')
plt.axis('equal')
plt.legend()
plt.show()

# Пример задачи коммивояжёра с использованием NetworkX
import networkx as nx
from itertools import permutations

# Создание полного графа
def create_tsp_graph(cities, distances):
G = nx.Graph()
for i, city in enumerate(cities):
G.add_node(i, pos=(city[0], city[1]), name=city[2])

for i in range(len(cities)):
for j in range(i+1, len(cities)):
G.add_edge(i, j, weight=distances[i][j])

return G

# Полный перебор для задачи коммивояжёра (только для малого числа городов)
def solve_tsp_brute_force(G):
nodes = list(G.nodes())
n = len(nodes)

# Перебор всех возможных маршрутов
all_routes = list(permutations(nodes))
best_route = None
best_length = float('inf')

for route in all_routes:
length = 0
for i in range(n):
length += G[route[i]][route[(i+1) % n]]['weight']

if length < best_length:
best_length = length
best_route = route

return best_route, best_length

# Пример городов (координаты и названия)
cities = [
(0, 0, "A"),
(1, 3, "B"),
(4, 1, "C"),
(3, 5, "D"),
(5, 8, "E")
]

# Матрица расстояний
distances = [
[0, 3.2, 4.1, 5.8, 9.5],
[3\.2, 0, 3.6, 4.0, 7.1],
[4\.1, 3.6, 0, 4.3, 6.8],
[5\.8, 4.0, 4.3, 0, 3.2],
[9\.5, 7.1, 6.8, 3.2, 0]
]

G = create_tsp_graph(cities, distances)

# Решение задачи
best_route, best_length = solve_tsp_brute_force(G)

print(f"Оптимальный маршрут:")
route_names = [G.nodes[node]['name'] for node in best_route] + [G.nodes[best_route[0]]['name']]
print(" -> ".join(route_names))
print(f"Общая длина: {best_length:.1f}")

# Визуализация решения
pos = nx.get_node_attributes(G, 'pos')
plt.figure(figsize=(10, 8))
nx.draw(G, pos, with_labels=True, node_color='skyblue', node_size=1500, font_weight='bold')

# Отображение весов рёбер
edge_labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)

# Отображение оптимального маршрута
route_edges = [(best_route[i], best_route[(i+1) % len(best_route)]) for i in range(len(best_route))]
nx.draw_networkx_edges(G, pos, edgelist=route_edges, width=2, edge_color='r')

plt.title(f"Задача коммивояжёра: оптимальный маршрут (длина {best_length:.1f})")
plt.axis('off')
plt.show()

# Пример: моделирование распространения эпидемии с помощью модели SIR
from scipy.integrate import solve_ivp
import numpy as np
import matplotlib.pyplot as plt

# SIR-модель: дифференциальные уравнения
def sir_model(t, y, beta, gamma):
S, I, R = y
N = S + I + R
dS_dt = -beta * S * I / N
dI_dt = beta * S * I / N – gamma * I
dR_dt = gamma * I
return [dS_dt, dI_dt, dR_dt]

# Параметры модели
total_population = 1000
initial_infected = 1
initial_recovered = 0
initial_susceptible = total_population – initial_infected – initial_recovered

# Параметры заболевания
beta = 0.3 # Скорость передачи инфекции
gamma = 0.1 # Скорость выздоровления

# Начальные условия
y0 = [initial_susceptible, initial_infected, initial_recovered]

# Временной интервал
t_span = [0, 200]
t_eval = np.linspace(0, 200, 1000)

# Решение системы дифференциальных уравнений
solution = solve_ivp(
sir_model, 
t_span, 
y0, 
args=(beta, gamma),
t_eval=t_eval
)

# Результаты
t = solution.t
S = solution.y[0]
I = solution.y[1]
R = solution.y[2]

# Визуализация
plt.figure(figsize=(10, 6))
plt.plot(t, S, 'b-', label='Восприимчивые (S)')
plt.plot(t, I, 'r-', label='Инфицированные (I)')
plt.plot(t, R, 'g-', label='Выздоровевшие (R)')

plt.grid(True)
plt.xlabel('Время (дни)')
plt.ylabel('Количество людей')
plt.title('Модель SIR распространения эпидемии')
plt.legend()

# Нахождение пика эпидемии
peak_day = t[np.argmax(I)]


**Читайте также**
- [Последовательность Фибоначчи на Python: от рекурсии к оптимизации](/python/algoritm-fibonachchi-na-python-poshagovoe-rukovodstvo/)
- [Хэш-таблицы в Python: принцип работы и оптимизация кода](/python/hesh-tablicy-v-python-kak-oni-rabotayut-i-zachem-nuzhny/)
- [Подготовка к собеседованию: алгоритмические задачи на Python и LeetCode](/python/reshenie-zadach-na-python-leetcode-i-trenirovochnye-zadachi/)
- [Деревья и графы в Python: алгоритмы, структуры данных, решения](/python/derevya-i-grafy-v-python-osnovy-i-primery/)
- [3 эффективных способа инверсии списков в Python: что выбрать](/python/inversiya-spiska-v-python-kak-eto-sdelat-i-zachem-nuzhno/)
- [8 эффективных алгоритмов поиска и сортировки на Python: примеры](/python/poisk-i-sortirovka-v-python-osnovnye-algoritmy/)
- [10 главных операций с массивами Python для эффективной обработки данных](/python/rabota-s-massivami-v-python-osnovnye-operacii-i-primery/)
- [Визуализация алгоритмов в Python: 5 лучших библиотек для блок-схем](/python/sozdanie-blok-shem-i-vizualizaciya-algoritmov-na-python/)
- [Множества в Python: как эффективно находить пересечения данных](/python/peresechenie-mnozhestv-v-python-kak-eto-sdelat-i-zachem-nuzhno/)