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

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation

# Константы
q = 1.6e-19  # заряд частицы (Кулон)
m = 1.67e-27  # масса частицы (кг, протон)
B = 5.0  # магнитное поле (Тесла)
dt = 1e-9  # временной шаг (с)

# Параметры начального состояния
num_particles = 10  # количество частиц
v_perp = np.random.uniform(0.5e6, 1.5e6, num_particles)  # скорости перпендикулярно полю (м/с)
v_parallel = np.random.uniform(1e6, 3e6, num_particles)  # скорости вдоль поля (м/с)
theta = np.random.uniform(0, 2 * np.pi, num_particles)  # начальный угол

# Инициализация позиций частиц
r = np.zeros(num_particles)  # радиус
z = np.zeros(num_particles)  # положение вдоль оси
positions = np.zeros((num_particles, 1000, 3))  # траектория для каждой частицы

# Моделирование траектории для всех частиц
for p in range(num_particles):
    for t in range(1000):
        omega_c = q * B / m  # циклотронная частота (рад/с)
        theta[p] += omega_c * dt
        if theta[p] > 2 * np.pi:
            theta[p] -= 2 * np.pi

        r = v_perp[p] / omega_c * np.cos(theta[p])
        z[p] += v_parallel[p] * dt

        positions[p, t] = [r, z[p], theta[p]]

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Настройка графиков для частиц
lines = [ax.plot([], [], [], lw=1)[0] for _ in range(num_particles)]
points = [ax.plot([], [], [], 'o')[0] for _ in range(num_particles)]

ax.set_xlim([-0.05, 0.05])
ax.set_ylim([-0.05, 0.05])
ax.set_zlim([0, 0.2])

ax.set_xlabel('X (м)')
ax.set_ylabel('Y (м)')
ax.set_zlabel('Z (м)')
ax.set_title('Модель удержания множества частиц в токамаке')

# Функция для обновления анимации
def update(num):
    for p in range(num_particles):
        x = positions[p, :num, 0] * np.cos(positions[p, :num, 2])
        y = positions[p, :num, 0] * np.sin(positions[p, :num, 2])
        z = positions[p, :num, 1]
        lines[p].set_data(x, y)
        lines[p].set_3d_properties(z)
        points[p].set_data(x[-1:], y[-1:])
        points[p].set_3d_properties(z[-1:])
    return lines + points

# Анимация
ani = FuncAnimation(fig, update, frames=1000, interval=10, blit=True)

plt.show()

### Что изменилось:
1. Множественные частицы: Добавлено num_particles частиц. Каждая из них имеет случайные начальные скорости и углы.
2. Обновление позиций: Траектория каждой частицы рассчитывается отдельно и хранится в массиве positions.
3. Анимация для всех частиц: Линии и точки создаются для каждой частицы, и их положение обновляется на каждом шаге.

Теперь вы можете наблюдать движение "облака" частиц в магнитном поле токамака, что лучше демонстрирует работу системы удержания.

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

Анимация кода выше 👆👆👆

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

Тут я за производтельность, безопасность и чистоту кода. Это кстати очень хориший вопрос на собеседовании, потому что тут все depends... И ответ на этот вопрос сильно определяет ваш уровень. Я люблю такие вопросы.

Линк на сам курс.

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

Познакомимся с редкой библиотекой для задач производительности и удобства работы с многопоточностью — `joblib`. Она полезна для эффективного параллельного выполнения задач и кеширования результатов.

---

### Установка joblib
Если библиотека не установлена:

pip install joblib

---

### Пример использования: параллельная обработка
Создадим пример, который выполняет вычисления факториалов для большого набора чисел с использованием многопоточности.

from joblib import Parallel, delayed
import math
import time

# Функция для вычисления факториала
def compute_factorial(n):
    return math.factorial(n)

def main():
    numbers = range(100000, 100010)  # Список больших чисел для вычисления факториала
    
    print("Вычисление факториалов параллельно...")
    start = time.time()
    
    # Параллельное выполнение
    results = Parallel(n_jobs=-1)(delayed(compute_factorial)(n) for n in numbers)
    
    end = time.time()
    print(f"Результаты: {[len(str(r)) for r in results]} (количество цифр в каждом факториале)")
    print(f"Время выполнения: {end - start:.2f} секунд")

if __name__ == "__main__":
    main()

### Объяснение:
1. Параллельное выполнение:
- Parallel(n_jobs=-1) использует все доступные ядра процессора для вычислений.
- delayed(compute_factorial) указывает функцию и её аргументы для выполнения.

2. Результаты:
- Код вычисляет факториалы для чисел от 100,000 до 100,009.
- Вместо вывода самих чисел (очень большие), выводится количество цифр в результатах.

3. Время выполнения:
- Параллельное выполнение значительно ускоряет обработку по сравнению с последовательным.

### Преимущества joblib:
- Простота использования.
- Поддержка автоматического распараллеливания.
- Возможность кеширования результатов для экономии времени на повторных вычислениях.

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

Вот интересный и полезный лайфхак на чистом Python: реализация LRU (Least Recently Used) кэша без использования дополнительных библиотек.

### Что это?
LRU-кэш сохраняет результаты вызовов функций для ускорения последующих вычислений. Если кэш переполняется, удаляется самый "старый" элемент.

---

### Реализация LRU-кэша:

from collections import deque

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}  # Хранение данных
        self.order = deque()  # Порядок использования
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1  # Если ключ не найден
        # Обновляем порядок использования
        self.order.remove(key)
        self.order.append(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            # Обновляем значение и порядок использования
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            # Удаляем самый старый элемент
            oldest_key = self.order.popleft()
            del self.cache[oldest_key]
        # Добавляем новый элемент
        self.cache[key] = value
        self.order.append(key)

# Пример использования
cache = LRUCache(3)
cache.put(1, "A")  # Добавляем ключ 1
cache.put(2, "B")  # Добавляем ключ 2
cache.put(3, "C")  # Добавляем ключ 3

print(cache.get(1))  # "A" - обновляем порядок ключа 1
cache.put(4, "D")  # Добавляем ключ 4, удаляем самый старый (ключ 2)

print(cache.get(2))  # -1 (удалён из-за переполнения)
print(cache.get(3))  # "C"
print(cache.get(4))  # "D"

---

### Как это работает:
1. Кэш:
- Хранит значения по ключам.
- self.cache — словарь для хранения данных.
2. Порядок использования:
- deque отслеживает порядок добавления/обновления ключей.
- Если кэш переполняется, удаляется элемент, добавленный раньше всех.
3. Методы:
- get: Возвращает значение по ключу и обновляет порядок.
- put: Добавляет новый элемент, удаляя самый старый при необходимости.

---

### Чем полезно:
- Позволяет ускорить функции, повторяющие одни и те же вычисления.
- Это компактная реализация кэша без использования библиотек, которая полезна в ограниченных средах.

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

Проблема, связанная с переходом на 2000 год (известная как Y2K), возникала из-за хранения годов в виде двух цифр вместо четырёх, что приводило к ошибкам в вычислениях и интерпретации дат. Вот пример кода, демонстрирующего подобную проблему:

from datetime import datetime

# Демонстрация хранения года в виде двух цифр
def process_date(two_digit_year):
    try:
        # Преобразуем дату с фиксированным форматом
        date = datetime.strptime(f"01-01-{two_digit_year}", "%d-%m-%y")
        return date
    except ValueError as e:
        return f"Ошибка обработки даты: {e}"

# Пример с корректной интерпретацией дат
print(process_date("99"))  # Ожидается: 1999
print(process_date("00"))  # Проблема: интерпретируется как 2000

# Пример возможной ошибки
print(process_date("50"))  # В интервале 1950-2049 интерпретируется как 2050
print(process_date("49"))  # Интерпретируется как 1949

### Объяснение:
1. В datetime.strptime двухзначный год (`%y`) интерпретируется следующим образом:
- Если год в диапазоне 00-68, он считается частью 2000-х годов (например, 00 = 2000, 50 = 2050).
- Если год в диапазоне 69-99, он считается частью 1900-х годов (например, 99 = 1999).

### Возможные проблемы:
1. Неправильная интерпретация годов, выходящих за рамки 1900-2099.
2. Зависимость от правил интерпретации двухзначных годов, которые могут быть разными в других системах.

#### Исправление:
Всегда использовать четырёхзначный формат года (`%Y`), чтобы избежать таких проблем:

def process_date(four_digit_year):
    try:
        date = datetime.strptime(f"01-01-{four_digit_year}", "%d-%m-%Y")
        return date
    except ValueError as e:
        return f"Ошибка обработки даты: {e}"

# Теперь даты интерпретируются корректно
print(process_date("1999"))
print(process_date("2000"))
print(process_date("2050"))

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

Проблема, связанная с миллисекундным отсчетом от определенной эпохи, известна как "Unix Y2K" или "2038 Year Problem". Эта проблема возникает из-за того, что в системах, использующих 32-битные целые числа со знаком для представления времени (например, количество секунд, прошедших с эпохи Unix — 1 января 1970 года), число переполняется 19 января 2038 года.

### Демонстрация проблемы "2038 года" в Python

В этом примере используется библиотека datetime, но мы специально ограничим время 32-битным целым числом, чтобы воспроизвести ошибку:

import time
from datetime import datetime, timedelta

# Симуляция 32-битного ограничения
def simulate_32bit_time(seconds_since_epoch):
    # Ограничение на 32-битное значение со знаком (-2^31 до 2^31-1)
    MAX_INT_32 = 2**31 - 1
    MIN_INT_32 = -2**31

    if not (MIN_INT_32 <= seconds_since_epoch <= MAX_INT_32):
        raise OverflowError("Время вышло за пределы 32-битного диапазона!")

    # Преобразуем в дату
    return datetime(1970, 1, 1) + timedelta(seconds=seconds_since_epoch)

# Текущее время в секундах с 1 января 1970 года
current_time = int(time.time())
print("Текущее время:", simulate_32bit_time(current_time))

# Пример даты до переполнения
future_time = 2**31 - 1  # Максимальное значение для 32-битного числа
print("Дата на границе 32-битного диапазона:", simulate_32bit_time(future_time))

# Попытка перейти за границу 32-битного диапазона
try:
    overflow_time = 2**31  # Переполнение
    print("Дата после переполнения:", simulate_32bit_time(overflow_time))
except OverflowError as e:
    print("Ошибка:", e)

### Объяснение:
1. Эпоха Unix: Отсчет времени начинается с 1 января 1970 года, 00:00:00 UTC.
2. 32-битное ограничение: Максимальное значение 32-битного целого числа со знаком — 2,147,483,647 секунд, что соответствует времени 19 января 2038 года, 03:14:07 UTC.
3. Переполнение: При превышении этого значения число переходит в отрицательное, что может быть интерпретировано как время в 1901 году.

### Выход из ситуации:
1. Использование 64-битных целых чисел для представления времени, что решает проблему до 292 млрд лет (в случае signed int).
2. Обновление всех систем, работающих с 32-битным временем.

### Пример безопасного решения:
Современные версии Python уже используют 64-битные значения для работы с временем, поэтому проблемы переполнения нет. Однако, в системах с жестким ограничением разрядности (например, встроенные системы) всё ещё может быть актуальной.

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

Вот пример кода на Python, который демонстрирует Year 2107 Bug, связанную с ограничениями дат в файловой системе FAT32. Эта файловая система использует 7 бит для представления года (с 1980 года), поэтому максимальный год, который она может представить, — 2107.

### Пример кода:

import datetime

def fat32_date_encoding(year, month, day):
    """
    Кодирование даты в формате FAT32.
    """
    if not (1980 <= year <= 2107):
        raise ValueError("Год должен быть в диапазоне от 1980 до 2107 для FAT32!")
    
    # Вычисляем двоичный формат даты FAT32:
    encoded_date = ((year - 1980) << 9) | (month << 5) | day
    return encoded_date

def fat32_date_decoding(encoded_date):
    """
    Декодирование даты из формата FAT32.
    """
    year = 1980 + ((encoded_date >> 9) & 0x7F)  # 7 бит на год
    month = (encoded_date >> 5) & 0x0F          # 4 бита на месяц
    day = encoded_date & 0x1F                  # 5 бит на день
    return datetime.date(year, month, day)

# Демонстрация
try:
    # Кодируем дату 2107-12-31 (максимально возможная дата)
    encoded_date = fat32_date_encoding(2107, 12, 31)
    print(f"Дата 2107-12-31 закодирована как: {encoded_date:#018b}")

    # Декодируем дату обратно
    decoded_date = fat32_date_decoding(encoded_date)
    print(f"Декодированная дата: {decoded_date}")

    # Попытка закодировать дату за пределами допустимого диапазона
    encoded_invalid_date = fat32_date_encoding(2108, 1, 1)
    print(f"Дата 2108-01-01 закодирована как: {encoded_invalid_date:#018b}")

except ValueError as e:
    print("Ошибка:", e)

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

1. Кодирование даты в FAT32:
- Год: Хранится в 7 битах (1980-2107).
- Месяц: Хранится в 4 битах (1-12).
- День: Хранится в 5 битах (1-31).
- Итоговое значение даты представляет 16-битное число.

2. Максимальная дата:
- Максимально возможный год — 2107.
- После 31 декабря 2107 года невозможно корректно представить дату, так как значение года переполняется.

3. Результат работы:
- Корректные даты (например, 2107-12-31) кодируются и декодируются без проблем.
- Попытка закодировать дату 2108-01-01 вызывает ошибку.

### Вывод:

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

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

Рекурсия — это мощный инструмент, но в Python её использование ограничено максимальной глубиной рекурсии, которая по умолчанию составляет 1000 уровней (можно узнать через `sys.getrecursionlimit()`). Это ограничение установлено для предотвращения переполнения стека вызовов, которое может привести к краху программы.

---

### Пример кода: Ограничение на рекурсию

import sys

# Посмотрим текущий лимит рекурсии
print("Текущий лимит рекурсии:", sys.getrecursionlimit())

# Пример рекурсивной функции
def recursive_function(n):
    if n == 0:
        return 0
    return 1 + recursive_function(n - 1)

try:
    # Попробуем вызвать рекурсию глубже, чем лимит
    result = recursive_function(1500)  # Увеличьте число, чтобы проверить лимит
    print("Результат:", result)
except RecursionError as e:
    print("Ошибка рекурсии:", e)

---

### Увеличение лимита рекурсии

Если нужно увеличить глубину рекурсии, можно использовать sys.setrecursionlimit(). Это может быть полезно в задачах, где необходимы глубокие рекурсивные вызовы (например, обходы деревьев).

#### Код с увеличением лимита:

# Установим новый лимит рекурсии
sys.setrecursionlimit(2000)
print("Новый лимит рекурсии:", sys.getrecursionlimit())

try:
    # Теперь функция может углубиться больше
    result = recursive_function(1500)
    print("Результат:", result)
except RecursionError as e:
    print("Ошибка рекурсии даже с увеличением лимита:", e)

Важно: Увеличение лимита рекурсии может привести к нестабильности программы, особенно если доступно ограниченное количество памяти. Используйте это осторожно.

---

### Итеративный подход как альтернатива рекурсии

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

#### Пример итеративной версии:

def iterative_function(n):
    count = 0
    while n > 0:
        count += 1
        n -= 1
    return count

# Проверим итеративный метод на большом входном значении
result = iterative_function(15000)
print("Результат итеративной функции:", result)

---

### Практическое применение: Обход дерева

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

#### Пример:

# Рекурсивный обход дерева
class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

def recursive_tree_traversal(node):
    print(node.value)
    for child in node.children:
        recursive_tree_traversal(child)

# Построим дерево
root = Node(1)
current = root
for i in range(2, 1500):  # Глубокое дерево
    new_node = Node(i)
    current.children.append(new_node)
    current = new_node

try:
    recursive_tree_traversal(root)
except RecursionError as e:
    print("Ошибка рекурсии при обходе дерева:", e)

#### Итеративный обход дерева:

def iterative_tree_traversal(node):
    stack = [node]
    while stack:
        current = stack.pop()
        print(current.value)
        stack.extend(reversed(current.children))  # Добавляем детей в стек

# Обход дерева итеративно
iterative_tree_traversal(root)

---

### Вывод:
1. Рекурсия удобна, но ограничена глубиной, что делает её непрактичной для очень больших структур.
2. Увеличение лимита через sys.setrecursionlimit() может быть временным решением, но увеличивает риск краха программы.
3. Итеративные методы — более безопасная альтернатива для задач с большими объемами данных.

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