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

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from noise import pnoise2  # Убедитесь, что установлен пакет noise (pip install noise)

# Параметры сетки и шума
grid_size = 10
num_particles = 200
scale = 0.1  # Масштаб шума
speed = 0.05  # Скорость изменения шума
time_step = 0

# Инициализация начальных позиций частиц
particles_x = np.random.uniform(0, grid_size, num_particles)
particles_y = np.random.uniform(0, grid_size, num_particles)

# Функция для генерации поля ветра с использованием перлин-шума
def generate_wind_field(time):
    U = np.zeros((grid_size, grid_size))
    V = np.zeros((grid_size, grid_size))
    for i in range(grid_size):
        for j in range(grid_size):
            U[i, j] = pnoise2(i * scale, j * scale, octaves=3, base=int(time)) * 5
            V[i, j] = pnoise2(i * scale + 100, j * scale + 100, octaves=3, base=int(time)) * 5
    return U, V

# Настройка графика
fig, ax = plt.subplots(figsize=(8, 8))
ax.set_xlim(0, grid_size)
ax.set_ylim(0, grid_size)

# Начальная визуализация частиц и стрелок
scat = ax.scatter(particles_x, particles_y, color='blue', s=2)
U, V = generate_wind_field(time_step)
quiver = ax.quiver(np.linspace(0, grid_size, grid_size), np.linspace(0, grid_size, grid_size), U, V, color='red')

# Функция инициализации
def init():
    scat.set_offsets(np.c_[particles_x, particles_y])
    quiver.set_UVC(U, V)
    return scat, quiver

# Функция обновления анимации
def update(frame):
    global particles_x, particles_y, time_step
    U, V = generate_wind_field(time_step)
    time_step += speed

    # Обновление стрелок
    quiver.set_UVC(U, V)

    # Интерполяция скорости ветра для частиц
    particle_u = np.interp(particles_x, np.linspace(0, grid_size, grid_size), U[:, int(particles_y[0]) % grid_size])
    particle_v = np.interp(particles_y, np.linspace(0, grid_size, grid_size), V[int(particles_x[0]) % grid_size, :])

    # Обновление позиций частиц
    particles_x = (particles_x + particle_u * 0.1) % grid_size
    particles_y = (particles_y + particle_v * 0.1) % grid_size
    scat.set_offsets(np.c_[particles_x, particles_y])

    return scat, quiver

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=200, init_func=init, interval=50, blit=True)

plt.show()

### Объяснение:

1. Поле ветра: Используем pnoise2 для создания переменных U и V, которые определяют горизонтальные и вертикальные компоненты скорости ветра. Значения U и V изменяются со временем, создавая динамическое поле ветра.

2. Частицы: Частицы (синие точки) движутся по направлению ветра, обновляя свои позиции на каждом кадре на основе текущего значения U и V.

3. Стрелки (quiver): Красные стрелки отображают направление и скорость ветра в каждом кадре, обновляясь вместе с полем ветра.

4. Анимация: FuncAnimation обновляет позиции частиц и стрелок для каждого кадра, создавая плавное движение воздушных масс.

Подпишись 👉🏻 @KodduuPython 🤖

Анимация движения ветра. Код выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Пример кода для прогнозирования спроса на продукт с использованием временных рядов и модели ARIMA. Этот код поможет предсказать будущий спрос на продукт на основе предыдущих данных о продажах. ARIMA (AutoRegressive Integrated Moving Average) — популярная модель для анализа и прогнозирования временных рядов.

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error

# Загрузка данных о продажах
# Предположим, у нас есть временной ряд с ежедневными данными о продажах
data = pd.read_csv('sales_data.csv')
data['date'] = pd.to_datetime(data['date'])
data.set_index('date', inplace=True)

# Визуализируем данные
plt.figure(figsize=(10, 6))
plt.plot(data, label='Daily Sales')
plt.title('Sales Data')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Создание модели ARIMA
# (p, d, q) - параметры модели, их можно подбирать автоматически, но здесь поставим примерные значения
p, d, q = 5, 1, 2
model = ARIMA(data['sales'], order=(p, d, q))
fitted_model = model.fit()

# Прогноз на 30 дней вперед
forecast_steps = 30
forecast = fitted_model.forecast(steps=forecast_steps)

# Построение графика прогноза
plt.figure(figsize=(10, 6))
plt.plot(data, label='Historical Sales')
plt.plot(pd.date_range(data.index[-1], periods=forecast_steps+1, closed='right'), forecast, color='red', label='Forecast')
plt.title('Sales Forecast for Next 30 Days')
plt.xlabel('Date')
plt.ylabel('Sales')
plt.legend()
plt.show()

# Оценка точности модели (например, среднеквадратичная ошибка на последних 30 днях)
train_size = int(len(data) * 0.8)
train, test = data['sales'][:train_size], data['sales'][train_size:]
model = ARIMA(train, order=(p, d, q))
fitted_model = model.fit()
forecast_test = fitted_model.forecast(steps=len(test))
mse = mean_squared_error(test, forecast_test)
print(f"Mean Squared Error: {mse}")

### Объяснение:

1. Подготовка данных: Загружаем временной ряд продаж и визуализируем данные.
2. Создание модели: Настраиваем параметры модели ARIMA и обучаем её на исторических данных.
3. Прогноз: Строим прогноз на 30 дней вперед.
4. Оценка модели: Вычисляем среднеквадратичную ошибку (MSE) для тестовой выборки, чтобы оценить точность прогноза.

### Примечания:
- Параметры модели ARIMA (`p`, d, q`) можно подобрать автоматически с помощью библиотек, таких как `pmdarima, которая содержит функцию auto_arima, чтобы выбрать лучшие параметры на основе критериев оценки модели.
- Этот пример подходит для анализа и прогнозирования временных рядов, таких как продажи, спрос, посещаемость и другие временные данные.

Подпишись 👉🏻 @KodduuPython 🤖

Вот код для отображения видимого пути Марса на небесной сфере в течение 2024 года. Используем библиотеку Skyfield для расчета астрономических позиций и matplotlib для визуализации.

from skyfield.api import load, Topos
import matplotlib.pyplot as plt

# Загрузка эфемерида
ephemeris = load('de440s.bsp')
earth = ephemeris['earth']               # Центральное тело Земли
mars_barycenter = ephemeris['mars barycenter']  # Барицентр системы Марса

# Создаем местоположение наблюдателя на Земле
location = earth + Topos(latitude_degrees=0.0, longitude_degrees=0.0)

# Выбор временного интервала
timescale = load.timescale()
dates = timescale.utc(2024, range(1, 366))  # Каждый день 2024 года

# Координаты прямого восхождения (RA) и склонения (Dec) для каждого дня
ra_values = []
dec_values = []

for date in dates:
    astrometric = location.at(date).observe(mars_barycenter)
    ra, dec, distance = astrometric.radec()
    ra_values.append(ra.hours)
    dec_values.append(dec.degrees)

# Визуализация движения Марса на звездном небе
plt.figure(figsize=(10, 6))
plt.plot(ra_values, dec_values, label="Mars Path", color='red')
plt.xlabel("Right Ascension (hours)")
plt.ylabel("Declination (degrees)")
plt.title("Apparent Path of Mars on the Celestial Sphere in 2024")
plt.gca().invert_xaxis()  # Инверсия оси для астрономической системы
plt.legend()
plt.grid()
plt.show()

### Краткое объяснение:

1. Эфемеридные данные: Загружаем данные о положении планет из файла de440s.bsp.
2. Местоположение наблюдателя: Создаем объект, представляющий наблюдателя на Земле на экваторе.
3. Расчет траектории: Для каждого дня 2024 года рассчитываем прямое восхождение (RA) и склонение (Dec) Марса.
4. Визуализация: Строим график, показывающий видимое движение Марса на небесной сфере.

Подпишись 👉🏻 @KodduuPython 🤖

Отображения видимого пути Марса, код выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Надо помнить - в Python некоторые вещи могут зависеть от настроек инстанса интерпретатора.

Например вот такой случай, "print(a, b)" может выдавать разный вывод на Stepik и на вашем локальном Python. И не смотря на то, что при сравнении результата кода с expected здесь используется strip(), который должен срезать все пробелы спереди и сзади, вот в этом конкретном случае сравнение идет целиком всех букв сразу, и будет разница и fail при "print(a) print(b)" vs "print(a, b)", поэтому ВАЖНО использовать конструкции, которые не зависят от настроек интерпретатора, например "print(a + b)", вместо "print(a, b)".

Как понять что зависит, а что нет? 🤨 С этим сложнее - например достаточно знать синтаксис языка C, и его аналоги переиспользовать даже в Python, тогда все будет ok.

Подпишись 👉🏻 @KodduuPython 🤖

Тем не менее незнание С не особождает от ответственности 🧐 Если столкнулись с ситуацией когда визуально все ok, а оно говорит не совпадает 🤷 Надо прокачивать другой важный скилл разработчика - debugging и root cause analysis. Надо пойти в "любой" online diff checker и сравнить два текста, и увидеть что разница все таки есть. Кстати diff чекеру тоже доверять на 100% не надо, вот как в этом случае он показывает, что посимвольно разницы нет (снизу должен был показать красным добавленые пробелы), но кол-во символов то разное 👆Вот тут мы все и поняли 😀

Курс про который идет тут речь вот тут 🔥

Подпишись 👉🏻 @KodduuPython 🤖

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

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Параметры симуляции
num_particles = 50  # Число частиц вещества и антивещества
box_size = 10       # Размер области

# Начальные позиции и направления для частиц вещества и антивещества
positions_matter = np.random.uniform(0, box_size, (num_particles, 2))
positions_antimatter = np.random.uniform(0, box_size, (num_particles, 2))
velocities_matter = np.random.uniform(-1, 1, (num_particles, 2))
velocities_antimatter = np.random.uniform(-1, 1, (num_particles, 2))

# Создание графика
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(0, box_size)
ax.set_ylim(0, box_size)

matter_plot = ax.scatter(positions_matter[:, 0], positions_matter[:, 1], color='blue', label='Matter')
antimatter_plot = ax.scatter(positions_antimatter[:, 0], positions_antimatter[:, 1], color='red', label='Antimatter')
plt.legend()

# Функция обновления для анимации
def update(frame):
    global positions_matter, positions_antimatter

    # Обновляем позиции частиц
    positions_matter += velocities_matter
    positions_antimatter += velocities_antimatter

    # Отражение от стенок
    for pos, vel in [(positions_matter, velocities_matter), (positions_antimatter, velocities_antimatter)]:
        vel[pos < 0] *= -1
        vel[pos > box_size] *= -1

    # Проверка на столкновения и аннигиляцию
    for i, pos_m in enumerate(positions_matter):
        distances = np.linalg.norm(positions_antimatter - pos_m, axis=1)
        collision_indices = np.where(distances < 0.5)[0]  # Радиус аннигиляции

        # Удаление столкнувшихся частиц
        if len(collision_indices) > 0:
            positions_matter[i] = np.nan  # Устанавливаем NaN для "аннигилированных" частиц
            positions_antimatter[collision_indices] = np.nan

    # Обновляем отображение частиц
    matter_plot.set_offsets(positions_matter)
    antimatter_plot.set_offsets(positions_antimatter)

    return matter_plot, antimatter_plot

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=200, interval=50, blit=True)
plt.show()

### Объяснение:

1. Начальные позиции и скорости: Создаются случайные позиции и направления для частиц материи и антивещества в заданной области.
2. Отражение от стенок: Частицы отскакивают от стенок, если достигают границы области.
3. Проверка на аннигиляцию: Когда частица материи находится на определенном расстоянии от частицы антивещества, обе частицы "аннигилируют" — их позиции заменяются на NaN, чтобы их не отображать.
4. Анимация: FuncAnimation обновляет позиции и проверяет столкновения, создавая визуализацию аннигиляции.

### Ключевая идея:
Когда частица материи и антивещества сталкиваются, они аннигилируют, исчезая из пространства симуляции, что демонстрирует основную концепцию антивещества.

Подпишись 👉🏻 @KodduuPython 🤖

Анигиляция вещества и антивещества. Код выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Жадный алгоритм (Greedy Algorithm)
Жадный алгоритм — это метод решения оптимизационных задач, который на каждом шаге принимает локально оптимальное решение, надеясь, что оно приведет к глобально оптимальному результату. Он работает по принципу "бери, что лучше прямо сейчас", без учета возможных последствий в будущем.

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

def optimize_cashback_strategy(receipts, balance):
    """
    Оптимизировать стратегию начисления/списания баллов для максимизации кэшбэка и минимизации расходов.

    :param receipts: Список чеков (стоимость каждой покупки).
    :param balance: Начальный баланс баллов.
    :return: Список стратегий ('add' для начисления, 'redeem' для списания), итоговый баланс и суммарный кэшбэк.
    """
    strategies = []  # Список стратегий
    total_cashback = 0  # Суммарный кэшбэк

    for receipt in receipts:
        cashback = receipt * 0.10  # 10% кэшбэк от стоимости покупки

        if balance >= receipt:
            # Если баллов достаточно, выгоднее списать
            strategies.append('redeem')
            balance -= receipt  # Списываем баллы
        else:
            # Если баллов недостаточно, начисляем кэшбэк
            strategies.append('add')
            total_cashback += cashback
            balance += cashback  # Начисляем баллы в баланс

    return strategies, balance, total_cashback


# Пример данных
receipts = [200, 150, 300, 100, 250, 50, 400, 120, 80, 60]  # Стоимость каждой покупки
initial_balance = 500  # Начальный баланс баллов

# Оптимизация стратегии
strategies, final_balance, total_cashback = optimize_cashback_strategy(receipts, initial_balance)

# Вывод результатов
print("Чеки:", receipts)
print("Начальный баланс:", initial_balance)
print("Стратегии:", strategies)
print("Итоговый баланс:", final_balance)
print("Суммарный кэшбэк:", total_cashback)

### Пояснение алгоритма:
1. Баллы списываются только если текущего баланса хватает на покрытие стоимости чека. Это позволяет минимизировать расходы.
2. Кэшбэк начисляется, если недостаточно баллов для списания. Начисленные баллы добавляются к балансу.
3. В каждом шаге выбирается наиболее выгодный вариант: либо списание баллов, либо начисление кэшбэка.

### Пример работы:
Для списка чеков [200, 150, 300, 100, 250, 50, 400, 120, 80, 60] и начального баланса 500 программа подберет стратегию, которая максимизирует итоговый кэшбэк и минимизирует расходы.

Подпишись 👉🏻 @KodduuPython 🤖

### Задача о рюкзаке (Knapsack Problem)

Задача:
У вас есть рюкзак фиксированного объема W, и множество предметов, каждый из которых имеет вес w_i и ценность v_i. Нужно определить, какие предметы положить в рюкзак, чтобы максимизировать общую ценность, не превышая объема W.

---

### Жадный алгоритм для задачи о рюкзаке (Fractional Knapsack)

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

Принцип работы:
1. Считаем "ценность на единицу веса" для каждого предмета ( v_i / w_i ).
2. Сортируем предметы по убыванию этой ценности.
3. Идем по отсортированным предметам, добавляя их в рюкзак, пока есть место:
- Если предмет помещается целиком, кладем его.
- Если предмет не помещается, берем только часть, которая влезет.

---

### Код для жадного алгоритма (дробный рюкзак):

def fractional_knapsack(items, max_weight):
    """
    Жадный алгоритм для задачи о дробном рюкзаке.

    :param items: Список предметов в формате [(ценность, вес), ...].
    :param max_weight: Максимальный вес рюкзака.
    :return: Максимальная ценность и список взятых предметов (включая доли).
    """
    # Считаем ценность на единицу веса для каждого предмета и сортируем по убыванию
    items = sorted(items, key=lambda x: x[0] / x[1], reverse=True)
    
    total_value = 0  # Суммарная ценность
    taken_items = []  # Список взятых предметов (включая доли)
    
    for value, weight in items:
        if max_weight == 0:  # Если рюкзак заполнен
            break
        
        if weight <= max_weight:
            # Берем предмет целиком
            total_value += value
            max_weight -= weight
            taken_items.append((value, weight, 1))  # 1 означает "взято целиком"
        else:
            # Берем часть предмета
            fraction = max_weight / weight
            total_value += value * fraction
            taken_items.append((value, weight, fraction))
            max_weight = 0  # Рюкзак заполнен
    
    return total_value, taken_items


# Пример данных: (ценность, вес)
items = [
    (60, 10),  # Ценность 60, вес 10
    (100, 20),  # Ценность 100, вес 20
    (120, 30)   # Ценность 120, вес 30
]
max_weight = 50  # Максимальный вес рюкзака

# Решение задачи
max_value, selected_items = fractional_knapsack(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)
print("Выбранные предметы (ценность, вес, доля):")
for item in selected_items:
    print(item)

---

### Пример вывода:

Максимальная ценность: 240.0
Выбранные предметы (ценность, вес, доля):
(100, 20, 1)
(120, 30, 1)
(60, 10, 0.6666666666666666)

---

### Динамическое программирование для задачи целого рюкзака

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

def knapsack_dp(items, max_weight):
    """
    Задача о рюкзаке для целых предметов с использованием динамического программирования.

    :param items: Список предметов в формате [(ценность, вес), ...].
    :param max_weight: Максимальный вес рюкзака.
    :return: Максимальная ценность.
    """
    n = len(items)
    dp = [[0] * (max_weight + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        value, weight = items[i - 1]
        for w in range(max_weight + 1):
            if weight <= w:
                # Либо берем предмет, либо не берем
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weight] + value)
            else:
                dp[i][w] = dp[i - 1][w]

    return dp[n][max_weight]


# Пример данных
items = [
    (60, 10),  # Ценность 60, вес 10
    (100, 20),  # Ценность 100, вес 20
    (120, 30)   # Ценность 120, вес 30
]
max_weight = 50  # Максимальный вес рюкзака

# Решение задачи
max_value = knapsack_dp(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)

---

### Пример вывода для целого рюкзака:

Максимальная ценность: 220

Подпишись 👉🏻 @KodduuPython 🤖

Проанализировали сотни собесов по Python. Начали паковать курс "Топ 100 вопросов с реальных собеседований по Python (шпаргалка)" 👍

Странно - но есть вопросы которые прямо в топе, а есть не менее интересные, которые прямо редко задают 🤷 Перед собесом по идее надо учить, те что часто задают 🧐 Но и знать что-то из редких, может быть тоже критично 🤨 На картинке, то что в топе 🤷

Подпишись 👉🏻 @KodduuPython 🤖