y_dcm = {}
for p in products:
    for dc in distribution_centers:
        for m in markets:
            y_dcm[(p, dc, m)] = LpVariable(
                f"y_{p}_{dc}_{m}",
                lowBound=0,
                cat='Continuous'
            )

# ---------------------------
# 4. ЦЕЛЕВАЯ ФУНКЦИЯ
# ---------------------------
# Общие затраты = затраты на производство + затраты на перевозку от завода к складу + от склада к рынку
problem += lpSum(
    production_cost[f][p] * x_fdc[(p, f, dc)]
    + transport_cost_factory_dc[(f, dc)] * x_fdc[(p, f, dc)]
    for p in products
    for f in factories
    for dc in distribution_centers
) + lpSum(
    transport_cost_dc_market[(dc, m)] * y_dcm[(p, dc, m)]
    for p in products
    for dc in distribution_centers
    for m in markets
), "Total_Cost"

# ---------------------------
# 5. ОГРАНИЧЕНИЯ
# ---------------------------

# (A) Ограничения по производственным мощностям заводов: 
#     сумма отправленного товара p с завода f на все склады dc <= capacity[f][p]
for f in factories:
    for p in products:
        problem += lpSum(x_fdc[(p, f, dc)] for dc in distribution_centers) <= capacity[f][p], \
            f"ProdCapacity_{f}_{p}"

# (B) Ограничения по ёмкости складов: 
#     на складе dc общее кол-во хранимых товаров (прибывших от всех заводов) 
#     не должно превышать dc_capacity[dc], 
#     но! нужно учесть, что то, что пришло на склад, может сразу уехать на рынок. 
#     Если мы считаем, что склад одновременно может хранить всё, что приходит, 
#     и лимит — это некая "пропускная способность", то упростим до:
#         Σ(продуктов, заводов) x_fdc <= capacity_dc
#     В реальности часто вводят дополнительные переменные для учёта запасов. 
#     Сделаем упрощённо.
for dc in distribution_centers:
    problem += lpSum(x_fdc[(p, f, dc)] for p in products for f in factories) <= dc_capacity[dc], \
        f"StorageCapacity_{dc}"

# (C) Баланс на складе (поток товаров через склад):
#     кол-во товара p, пришедшее на склад dc, должно быть равно 
#     кол-ву, которое отгружается дальше в рынки (если мы предполагаем 0 складских запасов в конце).
#     Σ(factories) x_fdc = Σ(markets) y_dcm
for dc in distribution_centers:
    for p in products:
        problem += lpSum(x_fdc[(p, f, dc)] for f in factories) == lpSum(y_dcm[(p, dc, m)] for m in markets), \
            f"FlowBalance_{dc}_{p}"

# (D) Удовлетворение спроса в каждом рынке:
#     Σ(dc) y_dcm >= demand[m][p]
for m in markets:
    for p in products:
        problem += lpSum(y_dcm[(p, dc, m)] for dc in distribution_centers) >= demand[m][p], \
            f"Demand_{m}_{p}"

# ---------------------------
# 6. РЕШЕНИЕ ЗАДАЧИ
# ---------------------------
problem.solve()

# ---------------------------
# 7. ВЫВОД РЕЗУЛЬТАТОВ
# ---------------------------
print(f"Статус решения: {LpStatus[problem.status]}")
print(f"Минимальные совокупные затраты: {value(problem.objective):.2f}\n")

for (p, f, dc) in x_fdc:
    qty = x_fdc[(p, f, dc)].varValue
    if qty > 0:
        print(f"Производство {p} на {f}, отправка на {dc}: {qty}")

for (p, dc, m) in y_dcm:
    qty = y_dcm[(p, dc, m)].varValue
    if qty > 0:
        print(f"Отгрузка {p} со склада {dc} в {m}: {qty}")

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

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

Ниже приведён пример кода на Python, иллюстрирующего «задачу о маршрутах Деда Мороза» (упрощённая версия задачи коммивояжёра). В ней мы хотим найти оптимальный маршрут Деда Мороза, чтобы он мог доставить подарки в несколько домов (точек на карте), начиная и заканчивая в условном «Лапландском логистическом центре» (или просто в «домике Деда Мороза»).

Здесь мы используем библиотеку OR-Tools от Google (а не `pulp`). Если библиотеки нет, установите её:

pip install ortools

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

from ortools.constraint_solver import routing_enums
from ortools.constraint_solver import pywrapcp

def create_data_model():
    """
    Создаём структуру с входными данными.
    distance_matrix: матрица расстояний между всеми точками (0-я точка — «Лапландия»).
    num_vehicles: количество "транспортных средств" (один Дед Мороз).
    depot: индекс начальной/конечной точки (тоже «Лапландия»).
    """
    data = {}
    
    # Пример: у нас есть 6 домов + 1 "домик Деда Мороза" (всего 7 точек).
    # Матрицу расстояний можно задать произвольно или сгенерировать.
    # Ниже — условный пример (симметричная матрица).
    data['distance_matrix'] = [
        # От каждой точки до каждой (0-я строка — расстояния из «Лапландии»).
        [0,   10,  15,  20,  25,  30,  12],  # Lapland (0) -> ...
        [10,  0,   18,  13,  28,  15,  22],  # House1 (1) -> ...
        [15,  18,  0,   17,  16,  22,  15],  # House2 (2)
        [20,  13,  17,  0,   14,  19,  23],  # House3 (3)
        [25,  28,  16,  14,  0,   25,  20],  # House4 (4)
        [30,  15,  22,  19,  25,  0,   18],  # House5 (5)
        [12,  22,  15,  23,  20,  18,  0 ],  # House6 (6)
    ]
    data['num_vehicles'] = 1  # Дед Мороз «один»
    data['depot'] = 0         # Начальная (и конечная) точка — 0, то есть «Лапландия»
    return data

def main():
    # Создаём данные
    data = create_data_model()
    distance_matrix = data['distance_matrix']
    num_locations = len(distance_matrix)         # Всего точек (включая «Лапландию»)
    num_vehicles = data['num_vehicles']
    depot = data['depot']

    # Создаём менеджер маршрутов и модель
    manager = pywrapcp.RoutingIndexManager(
        num_locations,  # кол-во локаций (вершин)
        num_vehicles,   # кол-во «трансп. средств»
        depot           # индекс депо (старт/финиш)
    )
    
    routing = pywrapcp.RoutingModel(manager)

    # Функция-«коллбек», возвращающая расстояние между двумя точками
    def distance_callback(from_index, to_index):
        # Преобразуем внутренние индексы маршрутизатора в индексы из матрицы
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return distance_matrix[from_node][to_node]

    # Регистрируем функцию коллбека и присваиваем ей ID
    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    # Зададим параметры поиска (например, стратегию поиска маршрута)
    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    search_parameters.first_solution_strategy = (
        routing_enums.FirstSolutionStrategy.PATH_CHEAPEST_ARC
    )
    
    # По желанию — включим какую-нибудь эвристику локального поиска
    # search_parameters.local_search_metaheuristic = (
    #     routing_enums.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
    # )
    # search_parameters.time_limit.seconds = 5  # ограничение по времени

    # Запускаем решение
    solution = routing.SolveWithParameters(search_parameters)

if solution:
        # Выводим итоговый маршрут
        print("Оптимальный маршрут Деда Мороза (минимальное суммарное расстояние):")
        index = routing.Start(0)  # начинаем с депо (Лапландия)
        plan_output = "Лапландия -> "
        route_distance = 0
        while not routing.IsEnd(index):
            next_index = solution.Value(routing.NextVar(index))
            route_distance += routing.GetArcCostForVehicle(index, next_index, 0)
            plan_output += f"House{manager.IndexToNode(next_index)} -> "
            index = next_index
        plan_output += "Лапландия (конец)"
        print(plan_output)
        print(f"Общее расстояние: {route_distance}")
    else:
        print("Решение не найдено!")

if __name__ == '__main__':
    main()

### Пояснения

1. OR-Tools — это мощная библиотека от Google для решения задач оптимизации (в том числе маршрутизации, линейного и целочисленного программирования, расписаний и т. д.).
2. Ключевые моменты:
- distance_matrix: матрица расстояний между всеми точками (включая точку «Лапландии», где начинается и заканчивается маршрут).
- RoutingIndexManager и RoutingModel: объекты, которые отвечают за «оптимизационную модель».
- distance_callback: функция, которая для каждой пары «откуда–куда» возвращает расстояние.
- В конце мы получаем итоговый маршрут (последовательность посещения домов), чтобы суммарное расстояние было минимальным.

3. Мы предположили, что Дед Мороз должен объехать все дома (узлы) один раз и вернуться в исходную точку (в классической постановке — задача коммивояжёра). В результате мы ищем маршрут, минимизирующий общее расстояние путешествия.

4. В реальном мире можно добавлять множество дополнительных условий:
- Временные окна (должен доставить подарок до определённого времени).
- Ограничения по весу и объёму подарков (если у Деда Мороза несколько волшебных саней).
- Разные скорости движения или разные стоимости поездки (например, снежные заносы).

Но даже в таком упрощённом виде пример показывает, как другая библиотека (OR-Tools), а не PuLP, применяется для решения оптимизационной задачи на тему «доставки подарков Дедом Морозом».

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

NetworkX — это удобная и мощная библиотека для работы с графами на Python. С её помощью можно:

- Создавать графы (ориентированные и неориентированные)
- Добавлять вершины и рёбра
- Находить кратчайшие пути (алгоритмы Дейкстры, Беллмана — Форда и др.)
- Искать связные компоненты, вычислять центральности, кластеризации и многое другое

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

import networkx as nx

# Создадим неориентированный граф
G = nx.Graph()

# Добавим вершины (можно неявно при добавлении рёбер)
G.add_nodes_from(["A", "B", "C", "D", "E"])

# Добавим рёбра с весами
G.add_edge("A", "B", weight=2)
G.add_edge("A", "C", weight=5)
G.add_edge("B", "D", weight=3)
G.add_edge("C", "D", weight=1)
G.add_edge("D", "E", weight=4)

# Ищем кратчайший путь (по весам) из A в E
path = nx.dijkstra_path(G, source="A", target="E", weight="weight")
distance = nx.dijkstra_path_length(G, source="A", target="E", weight="weight")

print("Кратчайший путь A -> E:", path)
print(f"Общая длина пути: {distance}")

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

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

Вышла новая статья на pikabu "Как стать АйТишником в 2025 году (пошаговый план)". Суммировал опыт многих, кто пришел в ИТ из других сфер.

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

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

- Узлы графа (nodes) — это перекрёстки.
- Рёбра графа (edges) — это дороги между перекрёстками.
- У каждого ребра есть:
- длина дороги (в километрах),
- скорость (км/ч), с которой можно проехать этот участок.

Целевая метрика: время в пути (в часах). Мы хотим найти кратчайший (по времени) путь, а не по географическому расстоянию.

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

import networkx as nx

def build_city_graph():
    """
    Создаёт и возвращает ориентированный граф (DiGraph) с атрибутами:
    - distance (км)
    - speed (км/ч)
    """
    G = nx.DiGraph()

    # Добавим несколько перекрёстков (можно просто добавлять рёбра, 
    # тогда вершины создадутся автоматически)
    intersections = ["Warehouse", "A", "B", "C", "Store"]
    G.add_nodes_from(intersections)

    # Добавим дороги (рёбра) с атрибутами:
    # G.add_edge(откуда, куда, distance=..., speed=...)
    G.add_edge("Warehouse", "A", distance=3.0, speed=30.0)  
    G.add_edge("Warehouse", "B", distance=5.0, speed=40.0)
    G.add_edge("A", "C", distance=2.0, speed=20.0)
    G.add_edge("B", "C", distance=2.5, speed=35.0)
    G.add_edge("C", "Store", distance=4.0, speed=40.0)
    G.add_edge("A", "Store", distance=8.0, speed=60.0)  

    # Можно добавить и обратные направления, если дороги двусторонние
    G.add_edge("A", "Warehouse", distance=3.0, speed=30.0)  
    G.add_edge("B", "Warehouse", distance=5.0, speed=40.0)
    # И так далее...

    return G

def compute_travel_time(u, v, data):
    """
    Вычисляем время (часы) проезда по участку (u->v) на основе атрибутов distance и speed.
    data — словарь атрибутов ребра.
    """
    dist = data.get("distance", 1.0)
    spd = data.get("speed", 1.0)
    return dist / spd  # время = расстояние/скорость

def main():
    # 1. Строим граф
    G = build_city_graph()

    # 2. Считаем «вес» каждого ребра как время
    #    Для поиска кратчайшего пути по времени используем атрибуты distance и speed.
    #    NetworkX позволяет указать коллбэк (функцию), которая вычисляет вес «на лету»,
    #    но здесь, для наглядности, прямо создадим новый атрибут "time".
    for u, v, data in G.edges(data=True):
        data["time"] = compute_travel_time(u, v, data)

    # 3. Ищем кратчайший маршрут по атрибуту "time"
    start = "Warehouse"
    end = "Store"

    # Используем алгоритм Дейкстры (dijkstra_path) или любой другой
    path = nx.dijkstra_path(G, source=start, target=end, weight="time")
    total_time = nx.dijkstra_path_length(G, source=start, target=end, weight="time")

    print("Самый быстрый маршрут:", " -> ".join(path))
    print(f"Общее время в пути (часы): {total_time:.2f}")

if __name__ == "__main__":
    main()

### Что происходит в коде?

1. build_city_graph() — создаёт ориентированный граф (DiGraph). Каждая дорога (ребро) имеет:
- distance: длина участка (км),
- speed: доступная скорость движения (км/ч).

2. compute_travel_time() — функция для расчёта времени в пути (в часах) = \(\text{distance} / \text{speed}\).

3. Мы в цикле по всем рёбрам графа (G.edges(data=True)) создаём новый атрибут time, который потом используется в алгоритме Дейкстры.

4. nx.dijkstra_path и nx.dijkstra_path_length — стандартные методы NetworkX для нахождения кратчайшего пути и его «стоимости» (суммы весов) в взвешенном графе:
- source=start, target=end, weight="time" указывает, что в качестве веса ребра следует использовать именно атрибут time.

5. На выходе — маршрут (список перекрёстков) и итоговое время.

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

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

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

import pennylane as qml
from pennylane import numpy as np

# Создаем устройство с двумя кубитами
dev = qml.device("default.qubit", wires=2)

# Определяем квантовую схему
@qml.qnode(dev)
def circuit(param):
    # Применяем поворот к первому кубиту
    qml.RX(param, wires=0)
    # Запутываем кубиты с помощью операции CNOT
    qml.CNOT(wires=[0, 1])
    # Возвращаем ожидаемые значения операторов Паули Z для обоих кубитов
    return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))

# Значение параметра, определяющее степень запутанности
param_value = np.pi / 2

# Выполняем квантовую схему и выводим результаты измерений
result = circuit(param_value)
print(result)

### Объяснение кода

1. Импорт библиотек: Импортируем необходимые модули из библиотеки PennyLane для работы с квантовыми схемами.
2. Создание устройства: Определяем квантовое устройство с двумя кубитами.
3. Определение квантовой схемы:
- Используется декоратор @qml.qnode(dev), чтобы создать квантовую схему.
- Применяется операция поворота к первому кубиту, что изменяет его состояние.
- Затем применяется операция CNOT, которая запутывает два кубита.
- Возвращаются ожидаемые значения операторов Паули Z для каждого кубита, что позволяет оценить их состояния после измерения.
4. Выполнение схемы: Устанавливаем значение параметра для максимизации запутанности и выводим результаты измерений.

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

Вот пример кода на Python, который показывает основные частицы Стандартной модели, их категории и основные различия:

class Particle:
    def __init__(self, name, type_, charge, mass, spin):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass
        self.spin = spin

    def __str__(self):
        return f"{self.name}: {self.type_}, Charge: {self.charge}, Mass: {self.mass} GeV/c², Spin: {self.spin}"


# Создаем частицы
particles = [
    # Кварки
    Particle("Up", "Quark", "+2/3", 0.0022, "1/2"),
    Particle("Down", "Quark", "-1/3", 0.0047, "1/2"),
    Particle("Charm", "Quark", "+2/3", 1.27, "1/2"),
    Particle("Strange", "Quark", "-1/3", 0.096, "1/2"),
    Particle("Top", "Quark", "+2/3", 173.1, "1/2"),
    Particle("Bottom", "Quark", "-1/3", 4.18, "1/2"),
    
    # Лептоны
    Particle("Electron", "Lepton", "-1", 0.000511, "1/2"),
    Particle("Electron Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Muon", "Lepton", "-1", 0.105, "1/2"),
    Particle("Muon Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    Particle("Tau", "Lepton", "-1", 1.777, "1/2"),
    Particle("Tau Neutrino", "Lepton", "0", "<0.000001", "1/2"),
    
    # Бозоны
    Particle("Photon", "Boson", "0", "0", "1"),
    Particle("W+", "Boson", "+1", 80.379, "1"),
    Particle("W-", "Boson", "-1", 80.379, "1"),
    Particle("Z", "Boson", "0", 91.1876, "1"),
    Particle("Gluon", "Boson", "0", "0", "1"),
    Particle("Higgs", "Boson", "0", 125.1, "0"),
]

# Группируем частицы по типу
grouped_particles = {}
for particle in particles:
    grouped_particles.setdefault(particle.type_, []).append(particle)

# Выводим информацию о частицах
for type_, particles_list in grouped_particles.items():
    print(f"{type_}s:")
    for particle in particles_list:
        print(f"  - {particle}")
    print()

### Вывод программы
Этот код создает объект Particle, который содержит свойства, такие как название, тип, заряд, масса и спин частицы. Затем он группирует частицы по категориям (кварки, лептоны, бозоны) и выводит их список.

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

Quarks:
  - Up: Quark, Charge: +2/3, Mass: 0.0022 GeV/c², Spin: 1/2
  - Down: Quark, Charge: -1/3, Mass: 0.0047 GeV/c², Spin: 1/2
  ...

Leptons:
  - Electron: Lepton, Charge: -1, Mass: 0.000511 GeV/c², Spin: 1/2
  - Electron Neutrino: Lepton, Charge: 0, Mass: <0.000001 GeV/c², Spin: 1/2
  ...

Bosons:
  - Photon: Boson, Charge: 0, Mass: 0 GeV/c², Spin: 1
  - W+: Boson, Charge: +1, Mass: 80.379 GeV/c², Spin: 1
  ...

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

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

Вот пример кода на Python, который показывает, как из частиц Стандартной модели формируются атомы и молекулы.

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Molecule:
    def __init__(self, atoms):
        self.atoms = atoms

    def molecular_formula(self):
        element_count = {}
        for atom in self.atoms:
            symbol = f"Element-{atom.atomic_number()}"
            element_count[symbol] = element_count.get(symbol, 0) + 1
        return "".join(f"{symbol}{count if count > 1 else ''}" for symbol, count in element_count.items())

    def __str__(self):
        return f"Molecule: {self.molecular_formula()}"

# Пример: Создание атомов водорода и кислорода
hydrogen = Atom(protons=[Proton()], neutrons=[Neutron()], electrons=[Particle("Electron", "Lepton", "-1", 0.000511)])
oxygen = Atom(protons=[Proton() for _ in range(8)],
              neutrons=[Neutron() for _ in range(8)],
              electrons=[Particle("Electron", "Lepton", "-1", 0.000511) for _ in range(8)])

# Пример: Создание молекулы воды (H2O)
water = Molecule(atoms=[hydrogen, hydrogen, oxygen])

# Вывод информации
print(hydrogen)
print(oxygen)
print(water)

Этот код создает атомы, используя протоны, нейтроны и электроны, а затем объединяет атомы в молекулы.

Пример:

1. Атомы водорода и кислорода строятся из протонов, нейтронов и электронов.
2. Молекула воды (H₂O) создается из двух атомов водорода и одного атома кислорода.

Когда вы запустите этот код, вы получите вывод, показывающий структуру атомов и молекул. Например:

Atom: Atomic Number = 1, Mass Number = 2, Neutral = True
Atom: Atomic Number = 8, Mass Number = 16, Neutral = True
Molecule: Element-1H2Element-8O

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

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

class Particle:
    def __init__(self, name, type_, charge, mass):
        self.name = name
        self.type_ = type_
        self.charge = charge
        self.mass = mass

class Proton:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "+1"

class Neutron:
    def __init__(self):
        self.quarks = [Particle("Up", "Quark", "+2/3", 0.0022),
                       Particle("Down", "Quark", "-1/3", 0.0047),
                       Particle("Down", "Quark", "-1/3", 0.0047)]
        self.charge = "0"

class Atom:
    def __init__(self, protons, neutrons, electrons):
        self.protons = protons
        self.neutrons = neutrons
        self.electrons = electrons

    def atomic_number(self):
        return len(self.protons)

    def mass_number(self):
        return len(self.protons) + len(self.neutrons)

    def is_neutral(self):
        return len(self.protons) == len(self.electrons)

    def __str__(self):
        return (f"Atom: Atomic Number = {self.atomic_number()}, Mass Number = {self.mass_number()}, "
                f"Neutral = {self.is_neutral()}")

class Element:
    def __init__(self, symbol, name, atomic_number, atomic_mass):
        self.symbol = symbol
        self.name = name
        self.atomic_number = atomic_number
        self.atomic_mass = atomic_mass

    def __str__(self):
        return f"{self.symbol} ({self.name}): Atomic Number = {self.atomic_number}, Atomic Mass = {self.atomic_mass}"

class PeriodicTable:
    def __init__(self):
        self.elements = []

    def add_element(self, element):
        self.elements.append(element)

    def display(self):
        for element in sorted(self.elements, key=lambda e: e.atomic_number):
            print(element)

# Создание элементов
hydrogen = Element("H", "Hydrogen", 1, 1.008)
helium = Element("He", "Helium", 2, 4.0026)
lithium = Element("Li", "Lithium", 3, 6.94)
beryllium = Element("Be", "Beryllium", 4, 9.0122)
boron = Element("B", "Boron", 5, 10.81)
carbon = Element("C", "Carbon", 6, 12.011)
nitrogen = Element("N", "Nitrogen", 7, 14.007)
oxygen = Element("O", "Oxygen", 8, 15.999)
fluorine = Element("F", "Fluorine", 9, 18.998)
neon = Element("Ne", "Neon", 10, 20.180)

# Создание таблицы Менделеева
periodic_table = PeriodicTable()
periodic_table.add_element(hydrogen)
periodic_table.add_element(helium)
periodic_table.add_element(lithium)
periodic_table.add_element(beryllium)
periodic_table.add_element(boron)
periodic_table.add_element(carbon)
periodic_table.add_element(nitrogen)
periodic_table.add_element(oxygen)
periodic_table.add_element(fluorine)
periodic_table.add_element(neon)

# Вывод таблицы
periodic_table.display()

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

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

import random

# Базовые элементы языка
nouns = ["человек", "кошка", "собака", "дерево", "река", "птица"]
verbs = ["идёт", "бежит", "летит", "плавает", "прыгает", "поёт"]
adjectives = ["красивый", "быстрый", "медленный", "зелёный", "громкий", "маленький"]
prepositions = ["на", "в", "под", "за", "перед", "около"]

# Функция для создания случайного предложения
def generate_sentence():
    noun1 = random.choice(nouns)
    noun2 = random.choice(nouns)
    verb = random.choice(verbs)
    adjective = random.choice(adjectives)
    preposition = random.choice(prepositions)

    # Создание структуры предложения
    sentence = f"{noun1.capitalize()} {verb} {preposition} {adjective} {noun2}."
    return sentence

# Генерация нескольких предложений
for _ in range(5):
    print(generate_sentence())

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

Кошка летит перед красивый человек.
Птица прыгает на громкий собака.
Человек идёт за зелёный река.
Собака поёт под маленький дерево.
Дерево плавает в быстрый птица.

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

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

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

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

Пример необычного языка можно смоделировать так:

import random

# Элементы для необычного языка
root_words = ["ba", "ka", "ta", "zi", "lo", "mu"]
modifiers = ["-li", "-ta", "-ku", "-zo", "-na"]  # Префиксы или суффиксы
actions = ["повтор", "ударение", "смена тона"]  # В языке смысл передаётся через интонации или повторения

# Генерация случайного слова
def generate_word():
    root = random.choice(root_words)
    modifier = random.choice(modifiers)
    word = root + modifier
    return word

# Генерация "предложения"
def generate_sentence_unusual():
    sentence = []
    for _ in range(random.randint(3, 6)):  # Количество слов в "предложении"
        word = generate_word()
        if random.choice([True, False]):
            word = word * 2  # Повторение для усиления смысла
        if random.choice([True, False]):
            word += "!"  # Интонация: добавление эмоционального контекста
        sentence.append(word)
    return " ".join(sentence)

# Генерация и вывод примеров
print("Пример языка с необычной структурой:")
for _ in range(5):
    print(generate_sentence_unusual())

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

Пример языка с необычной структурой:
balita balita! kazona kazona ziku!
muza! kalili kalili! lozoku!
kali kali! lozoku! tazona!
zili zili muza! zoku!
balita kazona muza muza!

### Особенности этого подхода:
1. Отсутствие грамматических категорий: здесь нет различий между существительными, глаголами и прилагательными.
2. Повторения: в некоторых языках повторение звуков усиливает значение.
3. Интонация: добавление "!" симулирует использование тона для изменения смысла.
4. Агглютинация: морфемы (например, -li, `-na`) используются для модификации корней.

Это демонстрирует, что не все языки основаны на привычных частях речи. Смысл может передаваться через звук, интонацию, порядок слов или даже повторения.

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

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

1. Одновременная передача нескольких значений в одном "слове" (каждое "слово" кодирует объект, действие и состояние).
2. Цветовая ассоциация слов: "значение" зависит от цвета, который "представляется" слову.
3. Динамика звучания: слово меняет смысл в зависимости от изменения его структуры во времени (например, удлинение или сокращение).

### Код моделирования:

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Генерация "предложения"
def generate_alien_sentence():
    sentence = []
    for _ in range(random.randint(3, 5)):  # Количество "слов"
        word = generate_base_word()
        word = apply_color(word)
        word = apply_modification(word)
        sentence.append(word)
    return " | ".join(sentence)

# Генерация примеров
print("Пример инопланетного языка:")
for _ in range(5):
    print(generate_alien_sentence())

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

Пример инопланетного языка:
красный @#$% | синий %&@* растяжение: %&@*-- | чёрный $*#$ импульс: $*#$~ | зелёный @@@ сжатие: @@
жёлтый @$%* сжатие: @$% | синий #$%& растяжение: #$%&- | красный &@*$ эхо: &@*$*$@&
чёрный *%# растяжение: *%#- | зелёный @#$% импульс: @#$%~ | жёлтый @# эхо: @##@
зелёный *&$ импульс: *&$~ | красный #%& растяжение: #%&-- | чёрный @# сжатие: @
красный %&@ сжатие: %& | синий @#$ растяжение: @#$- | жёлтый $% эхо: $%$%

### Особенности инопланетного языка:
1. Слова как многомерные структуры: каждое слово кодирует базовую форму, цвет, динамическую модификацию, что добавляет слои значения.
2. Цветовые значения: цвет добавляет семантику (например, "зелёный" может означать вопрос, "красный" — действие).
3. Динамика времени: модификации, такие как растяжение или эхо, добавляют эмоциональные или контекстуальные оттенки.
4. Нелинейная структура: слово может включать отражение (эхо) или импульсы, что невозможно в линейной речи.

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

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

Вот код, который кодирует сообщение в созданном ранее инопланетном языке, но я не скажу, какое именно сообщение закодировано.

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
    else:
        encoded_message.append("пробел")

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

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

Я добавил функцию для декодирования сообщения. Теперь код может раскодировать сообщение, используя упрощённые правила. Запусти обновлённый скрипт, чтобы проверить результат! 🚀

import random

# Основные элементы инопланетного языка
base_symbols = ["@", "#", "$", "%", "&", "*"]  # "Символы" как атомарные элементы
colors = ["красный", "синий", "зелёный", "жёлтый", "чёрный"]  # Ассоциированные цвета
modifications = ["растяжение", "сжатие", "импульс", "эхо"]  # Динамические правила

# Генерация базового "слова"
def generate_base_word():
    length = random.randint(3, 6)  # Длина слова
    return "".join(random.choice(base_symbols) for _ in range(length))

# Применение цвета
def apply_color(word):
    color = random.choice(colors)
    return f"{color} {word}"

# Применение модификации
def apply_modification(word):
    modification = random.choice(modifications)
    if modification == "растяжение":
        word = word + "-" * random.randint(1, 3)
    elif modification == "сжатие":
        word = word[:random.randint(1, len(word) - 1)]
    elif modification == "импульс":
        word = f"{word}~"
    elif modification == "эхо":
        word = word + word[::-1]  # Добавление зеркального слова
    return f"{modification}: {word}"

# Кодирование сообщения
message = "С Новым 2025 годом!"
encoded_message = []
coding_map = {}  # Карта соответствия символов

for char in message:
    if char.strip():  # Пропускаем пробелы и пустые символы
        base_word = generate_base_word()
        colored_word = apply_color(base_word)
        modified_word = apply_modification(colored_word)
        encoded_message.append(modified_word)
        coding_map[modified_word] = char  # Сохраняем соответствие символа и кодировки
    else:
        encoded_message.append("пробел")
        coding_map["пробел"] = " "

# Вывод закодированного сообщения
print("Закодированное сообщение:")
for encoded_word in encoded_message:
    print(encoded_word)

# Раскодирование сообщения
def decode_message(encoded_message, coding_map):
    decoded_message = []
    for encoded_word in encoded_message:
        decoded_message.append(coding_map.get(encoded_word, "?"))  # Используем карту для точного восстановления
    return "".join(decoded_message)

# Пример декодирования
print("\nДекодированное сообщение:")
decoded_message = decode_message(encoded_message, coding_map)
print(decoded_message)

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